src/gallium/state_trackers/omx/vid_dec.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 "pipe/p_screen.h"
  48 #include "pipe/p_video_codec.h"
  49 #include "util/u_memory.h"
  50 #include "util/u_surface.h"
  51 #include "vl/vl_video_buffer.h"
  52 #include "vl/vl_vlc.h"
  53
  54 #include "entrypoint.h"
  55 #include "vid_dec.h"
  56
  57 static OMX_ERRORTYPE vid_dec_Constructor(OMX_COMPONENTTYPE *comp, OMX_STRING name);
  58 static OMX_ERRORTYPE vid_dec_Destructor(OMX_COMPONENTTYPE *comp);
  59 static OMX_ERRORTYPE vid_dec_SetParameter(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR param);
  60 static OMX_ERRORTYPE vid_dec_GetParameter(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR param);
  61 static OMX_ERRORTYPE vid_dec_MessageHandler(OMX_COMPONENTTYPE *comp, internalRequestMessageType *msg);
  62 static OMX_ERRORTYPE vid_dec_DecodeBuffer(omx_base_PortType *port, OMX_BUFFERHEADERTYPE *buf);
  63 static OMX_ERRORTYPE vid_dec_FreeDecBuffer(omx_base_PortType *port, OMX_U32 idx, OMX_BUFFERHEADERTYPE *buf);
  64 static void vid_dec_FrameDecoded(OMX_COMPONENTTYPE *comp, OMX_BUFFERHEADERTYPE* input, OMX_BUFFERHEADERTYPE* output);
  65
  66 OMX_ERRORTYPE vid_dec_LoaderComponent(stLoaderComponentType *comp)
  67 {
  68    comp->componentVersion.s.nVersionMajor = 0;
  69    comp->componentVersion.s.nVersionMinor = 0;
  70    comp->componentVersion.s.nRevision = 0;
  71    comp->componentVersion.s.nStep = 1;
  72    comp->name_specific_length = 3;
  73
  74    comp->name = CALLOC(1, OMX_MAX_STRINGNAME_SIZE);
  75    if (comp->name == NULL)
  76       goto error;
  77
  78    comp->name_specific = CALLOC(comp->name_specific_length, sizeof(char *));
  79    if (comp->name_specific == NULL)
  80       goto error;
  81
  82    comp->role_specific = CALLOC(comp->name_specific_length, sizeof(char *));
  83    if (comp->role_specific == NULL)
  84       goto error;
  85
  86    comp->name_specific[0] = CALLOC(1, OMX_MAX_STRINGNAME_SIZE);
  87    if (comp->name_specific[0] == NULL)
  88       goto error_specific;
  89
  90    comp->name_specific[1] = CALLOC(1, OMX_MAX_STRINGNAME_SIZE);
  91    if (comp->name_specific[1] == NULL)
  92       goto error_specific;
  93
  94    comp->name_specific[2] = CALLOC(1, OMX_MAX_STRINGNAME_SIZE);
  95    if (comp->name_specific[2] == NULL)
  96       goto error_specific;
  97
  98    comp->role_specific[0] = CALLOC(1, OMX_MAX_STRINGNAME_SIZE);
  99    if (comp->role_specific[0] == NULL)
 100       goto error_specific;
 101
 102    comp->role_specific[1] = CALLOC(1, OMX_MAX_STRINGNAME_SIZE);
 103    if (comp->role_specific[1] == NULL)
 104       goto error_specific;
 105
 106    comp->role_specific[2] = CALLOC(1, OMX_MAX_STRINGNAME_SIZE);
 107    if (comp->role_specific[2] == NULL)
 108       goto error_specific;
 109
 110    strcpy(comp->name, OMX_VID_DEC_BASE_NAME);
 111    strcpy(comp->name_specific[0], OMX_VID_DEC_MPEG2_NAME);
 112    strcpy(comp->name_specific[1], OMX_VID_DEC_AVC_NAME);
 113    strcpy(comp->name_specific[2], OMX_VID_DEC_HEVC_NAME);
 114
 115    strcpy(comp->role_specific[0], OMX_VID_DEC_MPEG2_ROLE);
 116    strcpy(comp->role_specific[1], OMX_VID_DEC_AVC_ROLE);
 117    strcpy(comp->role_specific[2], OMX_VID_DEC_HEVC_ROLE);
 118
 119    comp->constructor = vid_dec_Constructor;
 120
 121    return OMX_ErrorNone;
 122
 123 error_specific:
 124    FREE(comp->role_specific[2]);
 125    FREE(comp->role_specific[1]);
 126    FREE(comp->role_specific[0]);
 127    FREE(comp->name_specific[2]);
 128    FREE(comp->name_specific[1]);
 129    FREE(comp->name_specific[0]);
 130
 131 error:
 132    FREE(comp->role_specific);
 133    FREE(comp->name_specific);
 134
 135    FREE(comp->name);
 136
 137    return OMX_ErrorInsufficientResources;
 138 }
 139
 140 static OMX_ERRORTYPE vid_dec_Constructor(OMX_COMPONENTTYPE *comp, OMX_STRING name)
 141 {
 142    vid_dec_PrivateType *priv;
 143    omx_base_video_PortType *port;
 144    struct pipe_screen *screen;
 145    OMX_ERRORTYPE r;
 146    int i;
 147
 148    assert(!comp->pComponentPrivate);
 149
 150    priv = comp->pComponentPrivate = CALLOC(1, sizeof(vid_dec_PrivateType));
 151    if (!priv)
 152       return OMX_ErrorInsufficientResources;
 153
 154    r = omx_base_filter_Constructor(comp, name);
 155    if (r)
 156       return r;
 157
 158    priv->profile = PIPE_VIDEO_PROFILE_UNKNOWN;
 159
 160    if (!strcmp(name, OMX_VID_DEC_MPEG2_NAME))
 161       priv->profile = PIPE_VIDEO_PROFILE_MPEG2_MAIN;
 162
 163    if (!strcmp(name, OMX_VID_DEC_AVC_NAME))
 164       priv->profile = PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH;
 165
 166    if (!strcmp(name, OMX_VID_DEC_HEVC_NAME))
 167       priv->profile = PIPE_VIDEO_PROFILE_HEVC_MAIN;
 168
 169    priv->BufferMgmtCallback = vid_dec_FrameDecoded;
 170    priv->messageHandler = vid_dec_MessageHandler;
 171    priv->destructor = vid_dec_Destructor;
 172
 173    comp->SetParameter = vid_dec_SetParameter;
 174    comp->GetParameter = vid_dec_GetParameter;
 175
 176    priv->screen = omx_get_screen();
 177    if (!priv->screen)
 178       return OMX_ErrorInsufficientResources;
 179
 180    screen = priv->screen->pscreen;
 181    priv->pipe = screen->context_create(screen, priv->screen, 0);
 182    if (!priv->pipe)
 183       return OMX_ErrorInsufficientResources;
 184
 185    if (!vl_compositor_init(&priv->compositor, priv->pipe)) {
 186       priv->pipe->destroy(priv->pipe);
 187       priv->pipe = NULL;
 188       return OMX_ErrorInsufficientResources;
 189    }
 190
 191    if (!vl_compositor_init_state(&priv->cstate, priv->pipe)) {
 192       vl_compositor_cleanup(&priv->compositor);
 193       priv->pipe->destroy(priv->pipe);
 194       priv->pipe = NULL;
 195       return OMX_ErrorInsufficientResources;
 196    }
 197
 198    priv->sPortTypesParam[OMX_PortDomainVideo].nStartPortNumber = 0;
 199    priv->sPortTypesParam[OMX_PortDomainVideo].nPorts = 2;
 200    priv->ports = CALLOC(2, sizeof(omx_base_PortType *));
 201    if (!priv->ports)
 202       return OMX_ErrorInsufficientResources;
 203
 204    for (i = 0; i < 2; ++i) {
 205       priv->ports[i] = CALLOC(1, sizeof(omx_base_video_PortType));
 206       if (!priv->ports[i])
 207          return OMX_ErrorInsufficientResources;
 208
 209       base_video_port_Constructor(comp, &priv->ports[i], i, i == 0);
 210    }
 211
 212    port = (omx_base_video_PortType *)priv->ports[OMX_BASE_FILTER_INPUTPORT_INDEX];
 213    strcpy(port->sPortParam.format.video.cMIMEType,"video/MPEG2");
 214    port->sPortParam.nBufferCountMin = 8;
 215    port->sPortParam.nBufferCountActual = 8;
 216    port->sPortParam.nBufferSize = DEFAULT_OUT_BUFFER_SIZE;
 217    port->sPortParam.format.video.nFrameWidth = 176;
 218    port->sPortParam.format.video.nFrameHeight = 144;
 219    port->sPortParam.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG2;
 220    port->sVideoParam.eCompressionFormat = OMX_VIDEO_CodingMPEG2;
 221    port->Port_SendBufferFunction = vid_dec_DecodeBuffer;
 222    port->Port_FreeBuffer = vid_dec_FreeDecBuffer;
 223
 224    port = (omx_base_video_PortType *)priv->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX];
 225    port->sPortParam.nBufferCountActual = 8;
 226    port->sPortParam.nBufferCountMin = 4;
 227    port->sPortParam.format.video.nFrameWidth = 176;
 228    port->sPortParam.format.video.nFrameHeight = 144;
 229    port->sPortParam.format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
 230    port->sVideoParam.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
 231
 232    return OMX_ErrorNone;
 233 }
 234
 235 static OMX_ERRORTYPE vid_dec_Destructor(OMX_COMPONENTTYPE *comp)
 236 {
 237    vid_dec_PrivateType* priv = comp->pComponentPrivate;
 238    int i;
 239
 240    if (priv->ports) {
 241       for (i = 0; i < priv->sPortTypesParam[OMX_PortDomainVideo].nPorts; ++i) {
 242          if(priv->ports[i])
 243             priv->ports[i]->PortDestructor(priv->ports[i]);
 244       }
 245       FREE(priv->ports);
 246       priv->ports=NULL;
 247    }
 248
 249    if (priv->pipe) {
 250       vl_compositor_cleanup_state(&priv->cstate);
 251       vl_compositor_cleanup(&priv->compositor);
 252       priv->pipe->destroy(priv->pipe);
 253    }
 254
 255    if (priv->screen)
 256       omx_put_screen();
 257
 258    return omx_workaround_Destructor(comp);
 259 }
 260
 261 static OMX_ERRORTYPE vid_dec_SetParameter(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR param)
 262 {
 263    OMX_COMPONENTTYPE *comp = handle;
 264    vid_dec_PrivateType *priv = comp->pComponentPrivate;
 265    OMX_ERRORTYPE r;
 266
 267    if (!param)
 268       return OMX_ErrorBadParameter;
 269
 270    switch(idx) {
 271    case OMX_IndexParamPortDefinition: {
 272       OMX_PARAM_PORTDEFINITIONTYPE *def = param;
 273
 274       r = omx_base_component_SetParameter(handle, idx, param);
 275       if (r)
 276          return r;
 277
 278       if (def->nPortIndex == OMX_BASE_FILTER_INPUTPORT_INDEX) {
 279          omx_base_video_PortType *port;
 280          unsigned framesize = def->format.video.nFrameWidth * def->format.video.nFrameHeight;
 281
 282          port = (omx_base_video_PortType *)priv->ports[OMX_BASE_FILTER_INPUTPORT_INDEX];
 283          port->sPortParam.nBufferSize = framesize * 512 / (16*16);
 284
 285          port = (omx_base_video_PortType *)priv->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX];
 286          port->sPortParam.format.video.nFrameWidth = def->format.video.nFrameWidth;
 287          port->sPortParam.format.video.nFrameHeight = def->format.video.nFrameHeight;
 288          port->sPortParam.format.video.nStride = def->format.video.nFrameWidth;
 289          port->sPortParam.format.video.nSliceHeight = def->format.video.nFrameHeight;
 290          port->sPortParam.nBufferSize = framesize*3/2;
 291
 292          priv->callbacks->EventHandler(comp, priv->callbackData, OMX_EventPortSettingsChanged,
 293                                        OMX_BASE_FILTER_OUTPUTPORT_INDEX, 0, NULL);
 294       }
 295       break;
 296    }
 297    case OMX_IndexParamStandardComponentRole: {
 298       OMX_PARAM_COMPONENTROLETYPE *role = param;
 299
 300       r = checkHeader(param, sizeof(OMX_PARAM_COMPONENTROLETYPE));
 301       if (r)
 302          return r;
 303
 304       if (!strcmp((char *)role->cRole, OMX_VID_DEC_MPEG2_ROLE)) {
 305          priv->profile = PIPE_VIDEO_PROFILE_MPEG2_MAIN;
 306       } else if (!strcmp((char *)role->cRole, OMX_VID_DEC_AVC_ROLE)) {
 307          priv->profile = PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH;
 308       } else if (!strcmp((char *)role->cRole, OMX_VID_DEC_HEVC_ROLE)) {
 309          priv->profile = PIPE_VIDEO_PROFILE_HEVC_MAIN;
 310       } else {
 311          return OMX_ErrorBadParameter;
 312       }
 313
 314       break;
 315    }
 316    case OMX_IndexParamVideoPortFormat: {
 317       OMX_VIDEO_PARAM_PORTFORMATTYPE *format = param;
 318       omx_base_video_PortType *port;
 319
 320       r = checkHeader(param, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
 321       if (r)
 322          return r;
 323
 324       if (format->nPortIndex > 1)
 325          return OMX_ErrorBadPortIndex;
 326
 327       port = (omx_base_video_PortType *)priv->ports[format->nPortIndex];
 328       memcpy(&port->sVideoParam, format, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
 329       break;
 330    }
 331    default:
 332       return omx_base_component_SetParameter(handle, idx, param);
 333    }
 334    return OMX_ErrorNone;
 335 }
 336
 337 static OMX_ERRORTYPE vid_dec_GetParameter(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR param)
 338 {
 339    OMX_COMPONENTTYPE *comp = handle;
 340    vid_dec_PrivateType *priv = comp->pComponentPrivate;
 341    OMX_ERRORTYPE r;
 342
 343    if (!param)
 344       return OMX_ErrorBadParameter;
 345
 346    switch(idx) {
 347    case OMX_IndexParamStandardComponentRole: {
 348       OMX_PARAM_COMPONENTROLETYPE *role = param;
 349
 350       r = checkHeader(param, sizeof(OMX_PARAM_COMPONENTROLETYPE));
 351       if (r)
 352          return r;
 353
 354       if (priv->profile == PIPE_VIDEO_PROFILE_MPEG2_MAIN)
 355          strcpy((char *)role->cRole, OMX_VID_DEC_MPEG2_ROLE);
 356       else if (priv->profile == PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH)
 357          strcpy((char *)role->cRole, OMX_VID_DEC_AVC_ROLE);
 358       else if (priv->profile == PIPE_VIDEO_PROFILE_HEVC_MAIN)
 359          strcpy((char *)role->cRole, OMX_VID_DEC_HEVC_ROLE);
 360
 361       break;
 362    }
 363
 364    case OMX_IndexParamVideoInit:
 365       r = checkHeader(param, sizeof(OMX_PORT_PARAM_TYPE));
 366       if (r)
 367          return r;
 368
 369       memcpy(param, &priv->sPortTypesParam[OMX_PortDomainVideo], sizeof(OMX_PORT_PARAM_TYPE));
 370       break;
 371
 372    case OMX_IndexParamVideoPortFormat: {
 373       OMX_VIDEO_PARAM_PORTFORMATTYPE *format = param;
 374       omx_base_video_PortType *port;
 375
 376       r = checkHeader(param, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
 377       if (r)
 378          return r;
 379
 380       if (format->nPortIndex > 1)
 381          return OMX_ErrorBadPortIndex;
 382
 383       port = (omx_base_video_PortType *)priv->ports[format->nPortIndex];
 384       memcpy(format, &port->sVideoParam, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
 385       break;
 386    }
 387
 388    default:
 389       return omx_base_component_GetParameter(handle, idx, param);
 390
 391    }
 392    return OMX_ErrorNone;
 393 }
 394
 395 static OMX_ERRORTYPE vid_dec_MessageHandler(OMX_COMPONENTTYPE* comp, internalRequestMessageType *msg)
 396 {
 397    vid_dec_PrivateType* priv = comp->pComponentPrivate;
 398
 399    if (msg->messageType == OMX_CommandStateSet) {
 400       if ((msg->messageParam == OMX_StateIdle ) && (priv->state == OMX_StateLoaded)) {
 401          if (priv->profile == PIPE_VIDEO_PROFILE_MPEG2_MAIN)
 402             vid_dec_mpeg12_Init(priv);
 403          else if (priv->profile == PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH)
 404             vid_dec_h264_Init(priv);
 405          else if (priv->profile == PIPE_VIDEO_PROFILE_HEVC_MAIN)
 406             vid_dec_h265_Init(priv);
 407
 408       } else if ((msg->messageParam == OMX_StateLoaded) && (priv->state == OMX_StateIdle)) {
 409          if (priv->shadow) {
 410             priv->shadow->destroy(priv->shadow);
 411             priv->shadow = NULL;
 412          }
 413          if (priv->codec) {
 414             priv->codec->destroy(priv->codec);
 415             priv->codec = NULL;
 416          }
 417       }
 418    }
 419
 420    return omx_base_component_MessageHandler(comp, msg);
 421 }
 422
 423 void vid_dec_NeedTarget(vid_dec_PrivateType *priv)
 424 {
 425    struct pipe_video_buffer templat = {};
 426    struct vl_screen *omx_screen;
 427    struct pipe_screen *pscreen;
 428
 429    omx_screen = priv->screen;
 430    assert(omx_screen);
 431
 432    pscreen = omx_screen->pscreen;
 433    assert(pscreen);
 434
 435    if (!priv->target) {
 436       memset(&templat, 0, sizeof(templat));
 437
 438       templat.chroma_format = PIPE_VIDEO_CHROMA_FORMAT_420;
 439       templat.width = priv->codec->width;
 440       templat.height = priv->codec->height;
 441       templat.buffer_format = pscreen->get_video_param(
 442             pscreen,
 443             PIPE_VIDEO_PROFILE_UNKNOWN,
 444             PIPE_VIDEO_ENTRYPOINT_BITSTREAM,
 445             PIPE_VIDEO_CAP_PREFERED_FORMAT
 446       );
 447       templat.interlaced = pscreen->get_video_param(
 448           pscreen,
 449           PIPE_VIDEO_PROFILE_UNKNOWN,
 450           PIPE_VIDEO_ENTRYPOINT_BITSTREAM,
 451           PIPE_VIDEO_CAP_PREFERS_INTERLACED
 452       );
 453       priv->target = priv->pipe->create_video_buffer(priv->pipe, &templat);
 454    }
 455 }
 456
 457 static void vid_dec_FreeInputPortPrivate(OMX_BUFFERHEADERTYPE *buf)
 458 {
 459    struct pipe_video_buffer *vbuf = buf->pInputPortPrivate;
 460    if (!vbuf)
 461       return;
 462
 463    vbuf->destroy(vbuf);
 464    buf->pInputPortPrivate = NULL;
 465 }
 466
 467 static OMX_ERRORTYPE vid_dec_DecodeBuffer(omx_base_PortType *port, OMX_BUFFERHEADERTYPE *buf)
 468 {
 469    OMX_COMPONENTTYPE* comp = port->standCompContainer;
 470    vid_dec_PrivateType *priv = comp->pComponentPrivate;
 471    unsigned i = priv->num_in_buffers++;
 472    OMX_ERRORTYPE r;
 473
 474    priv->in_buffers[i] = buf;
 475    priv->sizes[i] = buf->nFilledLen;
 476    priv->inputs[i] = buf->pBuffer;
 477    priv->timestamps[i] = buf->nTimeStamp;
 478
 479    while (priv->num_in_buffers > (!!(buf->nFlags & OMX_BUFFERFLAG_EOS) ? 0 : 1)) {
 480       bool eos = !!(priv->in_buffers[0]->nFlags & OMX_BUFFERFLAG_EOS);
 481       unsigned min_bits_left = eos ? 32 : MAX2(buf->nFilledLen * 8, 32);
 482       struct vl_vlc vlc;
 483
 484       vl_vlc_init(&vlc, priv->num_in_buffers, priv->inputs, priv->sizes);
 485
 486       if (priv->slice)
 487          priv->bytes_left = vl_vlc_bits_left(&vlc) / 8;
 488
 489       while (vl_vlc_bits_left(&vlc) > min_bits_left) {
 490          priv->Decode(priv, &vlc, min_bits_left);
 491          vl_vlc_fillbits(&vlc);
 492       }
 493
 494       if (priv->slice) {
 495          unsigned bytes = priv->bytes_left - vl_vlc_bits_left(&vlc) / 8;
 496
 497          priv->codec->decode_bitstream(priv->codec, priv->target, &priv->picture.base,
 498                                        1, &priv->slice, &bytes);
 499
 500          if (priv->num_in_buffers)
 501             priv->slice = priv->inputs[1];
 502          else
 503             priv->slice = NULL;
 504       }
 505
 506       if (eos && priv->frame_started)
 507          priv->EndFrame(priv);
 508
 509       if (priv->frame_finished) {
 510          priv->frame_finished = false;
 511          priv->in_buffers[0]->nFilledLen = priv->in_buffers[0]->nAllocLen;
 512          r = base_port_SendBufferFunction(port, priv->in_buffers[0]);
 513       } else if (eos) {
 514          vid_dec_FreeInputPortPrivate(priv->in_buffers[0]);
 515          priv->in_buffers[0]->nFilledLen = priv->in_buffers[0]->nAllocLen;
 516          r = base_port_SendBufferFunction(port, priv->in_buffers[0]);
 517       } else {
 518          priv->in_buffers[0]->nFilledLen = 0;
 519          r = port->ReturnBufferFunction(port, priv->in_buffers[0]);
 520       }
 521
 522       if (--priv->num_in_buffers) {
 523          unsigned delta = MIN2((min_bits_left - vl_vlc_bits_left(&vlc)) / 8, priv->sizes[1]);
 524
 525          priv->in_buffers[0] = priv->in_buffers[1];
 526          priv->sizes[0] = priv->sizes[1] - delta;
 527          priv->inputs[0] = priv->inputs[1] + delta;
 528          priv->timestamps[0] = priv->timestamps[1];
 529       }
 530
 531       if (r)
 532          return r;
 533    }
 534
 535    return OMX_ErrorNone;
 536 }
 537
 538 static OMX_ERRORTYPE vid_dec_FreeDecBuffer(omx_base_PortType *port, OMX_U32 idx, OMX_BUFFERHEADERTYPE *buf)
 539 {
 540    vid_dec_FreeInputPortPrivate(buf);
 541    return base_port_FreeBuffer(port, idx, buf);
 542 }
 543
 544 static void vid_dec_FillOutput(vid_dec_PrivateType *priv, struct pipe_video_buffer *buf,
 545                                OMX_BUFFERHEADERTYPE* output)
 546 {
 547    omx_base_PortType *port = priv->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX];
 548    OMX_VIDEO_PORTDEFINITIONTYPE *def = &port->sPortParam.format.video;
 549
 550    struct pipe_sampler_view **views;
 551    unsigned i, j;
 552    unsigned width, height;
 553
 554    views = buf->get_sampler_view_planes(buf);
 555
 556    for (i = 0; i < 2 /* NV12 */; i++) {
 557       if (!views[i]) continue;
 558       width = def->nFrameWidth;
 559       height = def->nFrameHeight;
 560       vl_video_buffer_adjust_size(&width, &height, i, buf->chroma_format, buf->interlaced);
 561       for (j = 0; j < views[i]->texture->array_size; ++j) {
 562          struct pipe_box box = {0, 0, j, width, height, 1};
 563          struct pipe_transfer *transfer;
 564          uint8_t *map, *dst;
 565          map = priv->pipe->transfer_map(priv->pipe, views[i]->texture, 0,
 566                   PIPE_TRANSFER_READ, &box, &transfer);
 567          if (!map)
 568             return;
 569
 570          dst = ((uint8_t*)output->pBuffer + output->nOffset) + j * def->nStride +
 571                i * def->nFrameWidth * def->nFrameHeight;
 572          util_copy_rect(dst,
 573             views[i]->texture->format,
 574             def->nStride * views[i]->texture->array_size, 0, 0,
 575             box.width, box.height, map, transfer->stride, 0, 0);
 576
 577          pipe_transfer_unmap(priv->pipe, transfer);
 578       }
 579    }
 580 }
 581
 582 static void vid_dec_deint(vid_dec_PrivateType *priv, struct pipe_video_buffer *src_buf,
 583                           struct pipe_video_buffer *dst_buf)
 584 {
 585    struct vl_compositor *compositor = &priv->compositor;
 586    struct vl_compositor_state *s = &priv->cstate;
 587    struct pipe_surface **dst_surface;
 588    struct u_rect dst_rect;
 589
 590    dst_surface = dst_buf->get_surfaces(dst_buf);
 591    vl_compositor_clear_layers(s);
 592
 593    dst_rect.x0 = 0;
 594    dst_rect.x1 = src_buf->width;
 595    dst_rect.y0 = 0;
 596    dst_rect.y1 = src_buf->height;
 597
 598    vl_compositor_set_yuv_layer(s, compositor, 0, src_buf, NULL, NULL, true);
 599    vl_compositor_set_layer_dst_area(s, 0, &dst_rect);
 600    vl_compositor_render(s, compositor, dst_surface[0], NULL, false);
 601
 602    dst_rect.x1 /= 2;
 603    dst_rect.y1 /= 2;
 604
 605    vl_compositor_set_yuv_layer(s, compositor, 0, src_buf, NULL, NULL, false);
 606    vl_compositor_set_layer_dst_area(s, 0, &dst_rect);
 607    vl_compositor_render(s, compositor, dst_surface[1], NULL, false);
 608 }
 609
 610 static void vid_dec_FrameDecoded(OMX_COMPONENTTYPE *comp, OMX_BUFFERHEADERTYPE* input,
 611                                  OMX_BUFFERHEADERTYPE* output)
 612 {
 613    vid_dec_PrivateType *priv = comp->pComponentPrivate;
 614    bool eos = !!(input->nFlags & OMX_BUFFERFLAG_EOS);
 615    OMX_TICKS timestamp;
 616
 617    if (!input->pInputPortPrivate) {
 618       input->pInputPortPrivate = priv->Flush(priv, &timestamp);
 619       if (timestamp != OMX_VID_DEC_TIMESTAMP_INVALID)
 620          input->nTimeStamp = timestamp;
 621    }
 622
 623    if (input->pInputPortPrivate) {
 624       if (output->pInputPortPrivate && !priv->disable_tunnel) {
 625          struct pipe_video_buffer *tmp, *vbuf, *new_vbuf;
 626
 627          tmp = output->pOutputPortPrivate;
 628          vbuf = input->pInputPortPrivate;
 629          if (vbuf->interlaced) {
 630             /* re-allocate the progressive buffer */
 631             omx_base_video_PortType *port;
 632             struct pipe_video_buffer templat = {};
 633
 634             port = (omx_base_video_PortType *)
 635                     priv->ports[OMX_BASE_FILTER_INPUTPORT_INDEX];
 636             memset(&templat, 0, sizeof(templat));
 637             templat.chroma_format = PIPE_VIDEO_CHROMA_FORMAT_420;
 638             templat.width = port->sPortParam.format.video.nFrameWidth;
 639             templat.height = port->sPortParam.format.video.nFrameHeight;
 640             templat.buffer_format = PIPE_FORMAT_NV12;
 641             templat.interlaced = false;
 642             new_vbuf = priv->pipe->create_video_buffer(priv->pipe, &templat);
 643
 644             /* convert the interlaced to the progressive */
 645             vid_dec_deint(priv, input->pInputPortPrivate, new_vbuf);
 646             priv->pipe->flush(priv->pipe, NULL, 0);
 647
 648             /* set the progrssive buffer for next round */
 649             vbuf->destroy(vbuf);
 650             input->pInputPortPrivate = new_vbuf;
 651          }
 652          output->pOutputPortPrivate = input->pInputPortPrivate;
 653          input->pInputPortPrivate = tmp;
 654       } else {
 655          vid_dec_FillOutput(priv, input->pInputPortPrivate, output);
 656       }
 657       output->nFilledLen = output->nAllocLen;
 658       output->nTimeStamp = input->nTimeStamp;
 659    }
 660
 661    if (eos && input->pInputPortPrivate)
 662       vid_dec_FreeInputPortPrivate(input);
 663    else
 664       input->nFilledLen = 0;
 665 }