Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  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_vlc.h"
  52.  
  53. #include "entrypoint.h"
  54. #include "vid_dec.h"
  55.  
  56. static OMX_ERRORTYPE vid_dec_Constructor(OMX_COMPONENTTYPE *comp, OMX_STRING name);
  57. static OMX_ERRORTYPE vid_dec_Destructor(OMX_COMPONENTTYPE *comp);
  58. static OMX_ERRORTYPE vid_dec_SetParameter(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR param);
  59. static OMX_ERRORTYPE vid_dec_GetParameter(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR param);
  60. static OMX_ERRORTYPE vid_dec_MessageHandler(OMX_COMPONENTTYPE *comp, internalRequestMessageType *msg);
  61. static OMX_ERRORTYPE vid_dec_DecodeBuffer(omx_base_PortType *port, OMX_BUFFERHEADERTYPE *buf);
  62. static OMX_ERRORTYPE vid_dec_FreeDecBuffer(omx_base_PortType *port, OMX_U32 idx, OMX_BUFFERHEADERTYPE *buf);
  63. static void vid_dec_FrameDecoded(OMX_COMPONENTTYPE *comp, OMX_BUFFERHEADERTYPE* input, OMX_BUFFERHEADERTYPE* output);
  64.  
  65. OMX_ERRORTYPE vid_dec_LoaderComponent(stLoaderComponentType *comp)
  66. {
  67.    comp->componentVersion.s.nVersionMajor = 0;
  68.    comp->componentVersion.s.nVersionMinor = 0;
  69.    comp->componentVersion.s.nRevision = 0;
  70.    comp->componentVersion.s.nStep = 1;
  71.    comp->name_specific_length = 2;
  72.  
  73.    comp->name = CALLOC(1, OMX_MAX_STRINGNAME_SIZE);
  74.    if (comp->name == NULL)
  75.       goto error;
  76.  
  77.    comp->name_specific = CALLOC(comp->name_specific_length, sizeof(char *));
  78.    if (comp->name_specific == NULL)
  79.       goto error;
  80.  
  81.    comp->role_specific = CALLOC(comp->name_specific_length, sizeof(char *));
  82.    if (comp->role_specific == NULL)
  83.       goto error;
  84.  
  85.    comp->name_specific[0] = CALLOC(1, OMX_MAX_STRINGNAME_SIZE);
  86.    if (comp->name_specific[0] == NULL)
  87.       goto error_specific;
  88.  
  89.    comp->name_specific[1] = CALLOC(1, OMX_MAX_STRINGNAME_SIZE);
  90.    if (comp->name_specific[1] == NULL)
  91.       goto error_specific;
  92.  
  93.    comp->role_specific[0] = CALLOC(1, OMX_MAX_STRINGNAME_SIZE);
  94.    if (comp->role_specific[0] == NULL)
  95.       goto error_specific;
  96.  
  97.    comp->role_specific[1] = CALLOC(1, OMX_MAX_STRINGNAME_SIZE);
  98.    if (comp->role_specific[1] == NULL)
  99.       goto error_specific;
  100.  
  101.    strcpy(comp->name, OMX_VID_DEC_BASE_NAME);
  102.    strcpy(comp->name_specific[0], OMX_VID_DEC_MPEG2_NAME);
  103.    strcpy(comp->name_specific[1], OMX_VID_DEC_AVC_NAME);
  104.  
  105.    strcpy(comp->role_specific[0], OMX_VID_DEC_MPEG2_ROLE);
  106.    strcpy(comp->role_specific[1], OMX_VID_DEC_AVC_ROLE);
  107.  
  108.    comp->constructor = vid_dec_Constructor;
  109.  
  110.    return OMX_ErrorNone;
  111.  
  112. error_specific:
  113.    FREE(comp->role_specific[1]);
  114.    FREE(comp->role_specific[0]);
  115.    FREE(comp->name_specific[1]);
  116.    FREE(comp->name_specific[0]);
  117.  
  118. error:
  119.    FREE(comp->role_specific);
  120.    FREE(comp->name_specific);
  121.  
  122.    FREE(comp->name);
  123.  
  124.    return OMX_ErrorInsufficientResources;
  125. }
  126.  
  127. static OMX_ERRORTYPE vid_dec_Constructor(OMX_COMPONENTTYPE *comp, OMX_STRING name)
  128. {
  129.    vid_dec_PrivateType *priv;
  130.    omx_base_video_PortType *port;
  131.    struct pipe_screen *screen;
  132.    OMX_ERRORTYPE r;
  133.    int i;
  134.  
  135.    assert(!comp->pComponentPrivate);
  136.  
  137.    priv = comp->pComponentPrivate = CALLOC(1, sizeof(vid_dec_PrivateType));
  138.    if (!priv)
  139.       return OMX_ErrorInsufficientResources;
  140.  
  141.    r = omx_base_filter_Constructor(comp, name);
  142.    if (r)
  143.         return r;
  144.  
  145.    priv->profile = PIPE_VIDEO_PROFILE_UNKNOWN;
  146.  
  147.    if (!strcmp(name, OMX_VID_DEC_MPEG2_NAME))
  148.       priv->profile = PIPE_VIDEO_PROFILE_MPEG2_MAIN;
  149.  
  150.    if (!strcmp(name, OMX_VID_DEC_AVC_NAME))
  151.       priv->profile = PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH;
  152.  
  153.    priv->BufferMgmtCallback = vid_dec_FrameDecoded;
  154.    priv->messageHandler = vid_dec_MessageHandler;
  155.    priv->destructor = vid_dec_Destructor;
  156.  
  157.    comp->SetParameter = vid_dec_SetParameter;
  158.    comp->GetParameter = vid_dec_GetParameter;
  159.  
  160.    priv->screen = omx_get_screen();
  161.    if (!priv->screen)
  162.       return OMX_ErrorInsufficientResources;
  163.  
  164.    screen = priv->screen->pscreen;
  165.    priv->pipe = screen->context_create(screen, priv->screen);
  166.    if (!priv->pipe)
  167.       return OMX_ErrorInsufficientResources;
  168.  
  169.    priv->sPortTypesParam[OMX_PortDomainVideo].nStartPortNumber = 0;
  170.    priv->sPortTypesParam[OMX_PortDomainVideo].nPorts = 2;
  171.    priv->ports = CALLOC(2, sizeof(omx_base_PortType *));
  172.    if (!priv->ports)
  173.       return OMX_ErrorInsufficientResources;
  174.  
  175.    for (i = 0; i < 2; ++i) {
  176.       priv->ports[i] = CALLOC(1, sizeof(omx_base_video_PortType));
  177.       if (!priv->ports[i])
  178.          return OMX_ErrorInsufficientResources;
  179.  
  180.       base_video_port_Constructor(comp, &priv->ports[i], i, i == 0);
  181.    }
  182.  
  183.    port = (omx_base_video_PortType *)priv->ports[OMX_BASE_FILTER_INPUTPORT_INDEX];
  184.    strcpy(port->sPortParam.format.video.cMIMEType,"video/MPEG2");
  185.    port->sPortParam.nBufferCountMin = 8;
  186.    port->sPortParam.nBufferCountActual = 8;
  187.    port->sPortParam.nBufferSize = DEFAULT_OUT_BUFFER_SIZE;
  188.    port->sPortParam.format.video.nFrameWidth = 176;
  189.    port->sPortParam.format.video.nFrameHeight = 144;
  190.    port->sPortParam.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG2;
  191.    port->sVideoParam.eCompressionFormat = OMX_VIDEO_CodingMPEG2;
  192.    port->Port_SendBufferFunction = vid_dec_DecodeBuffer;
  193.    port->Port_FreeBuffer = vid_dec_FreeDecBuffer;
  194.  
  195.    port = (omx_base_video_PortType *)priv->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX];
  196.    port->sPortParam.nBufferCountActual = 8;
  197.    port->sPortParam.nBufferCountMin = 4;
  198.    port->sPortParam.format.video.nFrameWidth = 176;
  199.    port->sPortParam.format.video.nFrameHeight = 144;
  200.    port->sPortParam.format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
  201.    port->sVideoParam.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
  202.  
  203.    return OMX_ErrorNone;
  204. }
  205.  
  206. static OMX_ERRORTYPE vid_dec_Destructor(OMX_COMPONENTTYPE *comp)
  207. {
  208.    vid_dec_PrivateType* priv = comp->pComponentPrivate;
  209.    int i;
  210.  
  211.    if (priv->ports) {
  212.       for (i = 0; i < priv->sPortTypesParam[OMX_PortDomainVideo].nPorts; ++i) {
  213.          if(priv->ports[i])
  214.             priv->ports[i]->PortDestructor(priv->ports[i]);
  215.       }
  216.       FREE(priv->ports);
  217.       priv->ports=NULL;
  218.    }
  219.  
  220.    if (priv->pipe)
  221.       priv->pipe->destroy(priv->pipe);
  222.  
  223.    if (priv->screen)
  224.       omx_put_screen();
  225.  
  226.    return omx_workaround_Destructor(comp);
  227. }
  228.  
  229. static OMX_ERRORTYPE vid_dec_SetParameter(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR param)
  230. {
  231.    OMX_COMPONENTTYPE *comp = handle;
  232.    vid_dec_PrivateType *priv = comp->pComponentPrivate;
  233.    OMX_ERRORTYPE r;
  234.  
  235.    if (!param)
  236.       return OMX_ErrorBadParameter;
  237.  
  238.    switch(idx) {
  239.    case OMX_IndexParamPortDefinition: {
  240.       OMX_PARAM_PORTDEFINITIONTYPE *def = param;
  241.  
  242.       r = omx_base_component_SetParameter(handle, idx, param);
  243.       if (r)
  244.          return r;
  245.  
  246.       if (def->nPortIndex == OMX_BASE_FILTER_INPUTPORT_INDEX) {
  247.          omx_base_video_PortType *port;
  248.          unsigned framesize = def->format.video.nFrameWidth * def->format.video.nFrameHeight;
  249.  
  250.          port = (omx_base_video_PortType *)priv->ports[OMX_BASE_FILTER_INPUTPORT_INDEX];
  251.          port->sPortParam.nBufferSize = framesize * 512 / (16*16);
  252.  
  253.          port = (omx_base_video_PortType *)priv->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX];
  254.          port->sPortParam.format.video.nFrameWidth = def->format.video.nFrameWidth;
  255.          port->sPortParam.format.video.nFrameHeight = def->format.video.nFrameHeight;
  256.          port->sPortParam.format.video.nStride = def->format.video.nFrameWidth;
  257.          port->sPortParam.format.video.nSliceHeight = def->format.video.nFrameHeight;
  258.          port->sPortParam.nBufferSize = framesize*3/2;
  259.  
  260.          priv->callbacks->EventHandler(comp, priv->callbackData, OMX_EventPortSettingsChanged,
  261.                                        OMX_BASE_FILTER_OUTPUTPORT_INDEX, 0, NULL);
  262.       }
  263.       break;
  264.    }
  265.    case OMX_IndexParamStandardComponentRole: {
  266.       OMX_PARAM_COMPONENTROLETYPE *role = param;
  267.  
  268.       r = checkHeader(param, sizeof(OMX_PARAM_COMPONENTROLETYPE));
  269.       if (r)
  270.          return r;
  271.  
  272.       if (!strcmp((char *)role->cRole, OMX_VID_DEC_MPEG2_ROLE)) {
  273.          priv->profile = PIPE_VIDEO_PROFILE_MPEG2_MAIN;
  274.       } else if (!strcmp((char *)role->cRole, OMX_VID_DEC_AVC_ROLE)) {
  275.          priv->profile = PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH;
  276.       } else {
  277.          return OMX_ErrorBadParameter;
  278.       }
  279.  
  280.       break;
  281.    }
  282.    case OMX_IndexParamVideoPortFormat: {
  283.       OMX_VIDEO_PARAM_PORTFORMATTYPE *format = param;
  284.       omx_base_video_PortType *port;
  285.  
  286.       r = checkHeader(param, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
  287.       if (r)
  288.          return r;
  289.  
  290.       if (format->nPortIndex > 1)
  291.          return OMX_ErrorBadPortIndex;
  292.  
  293.       port = (omx_base_video_PortType *)priv->ports[format->nPortIndex];
  294.       memcpy(&port->sVideoParam, format, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
  295.       break;
  296.    }
  297.    default:
  298.       return omx_base_component_SetParameter(handle, idx, param);
  299.    }
  300.    return OMX_ErrorNone;
  301. }
  302.  
  303. static OMX_ERRORTYPE vid_dec_GetParameter(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR param)
  304. {
  305.    OMX_COMPONENTTYPE *comp = handle;
  306.    vid_dec_PrivateType *priv = comp->pComponentPrivate;
  307.    OMX_ERRORTYPE r;
  308.  
  309.    if (!param)
  310.       return OMX_ErrorBadParameter;
  311.  
  312.    switch(idx) {
  313.    case OMX_IndexParamStandardComponentRole: {
  314.       OMX_PARAM_COMPONENTROLETYPE *role = param;
  315.  
  316.       r = checkHeader(param, sizeof(OMX_PARAM_COMPONENTROLETYPE));
  317.       if (r)
  318.          return r;
  319.  
  320.       if (priv->profile == PIPE_VIDEO_PROFILE_MPEG2_MAIN)
  321.          strcpy((char *)role->cRole, OMX_VID_DEC_MPEG2_ROLE);
  322.       else if (priv->profile == PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH)
  323.          strcpy((char *)role->cRole, OMX_VID_DEC_AVC_ROLE);
  324.  
  325.       break;
  326.    }
  327.  
  328.    case OMX_IndexParamVideoInit:
  329.       r = checkHeader(param, sizeof(OMX_PORT_PARAM_TYPE));
  330.       if (r)
  331.          return r;
  332.  
  333.       memcpy(param, &priv->sPortTypesParam[OMX_PortDomainVideo], sizeof(OMX_PORT_PARAM_TYPE));
  334.       break;
  335.  
  336.    case OMX_IndexParamVideoPortFormat: {
  337.       OMX_VIDEO_PARAM_PORTFORMATTYPE *format = param;
  338.       omx_base_video_PortType *port;
  339.  
  340.       r = checkHeader(param, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
  341.       if (r)
  342.          return r;
  343.  
  344.       if (format->nPortIndex > 1)
  345.          return OMX_ErrorBadPortIndex;
  346.  
  347.       port = (omx_base_video_PortType *)priv->ports[format->nPortIndex];
  348.       memcpy(format, &port->sVideoParam, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
  349.       break;
  350.    }
  351.  
  352.    default:
  353.       return omx_base_component_GetParameter(handle, idx, param);
  354.  
  355.    }
  356.    return OMX_ErrorNone;
  357. }
  358.  
  359. static OMX_ERRORTYPE vid_dec_MessageHandler(OMX_COMPONENTTYPE* comp, internalRequestMessageType *msg)
  360. {
  361.    vid_dec_PrivateType* priv = comp->pComponentPrivate;
  362.  
  363.    if (msg->messageType == OMX_CommandStateSet) {
  364.       if ((msg->messageParam == OMX_StateIdle ) && (priv->state == OMX_StateLoaded)) {
  365.          if (priv->profile == PIPE_VIDEO_PROFILE_MPEG2_MAIN)
  366.             vid_dec_mpeg12_Init(priv);
  367.          else if (priv->profile == PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH)
  368.             vid_dec_h264_Init(priv);
  369.  
  370.       } else if ((msg->messageParam == OMX_StateLoaded) && (priv->state == OMX_StateIdle)) {
  371.          if (priv->shadow) {
  372.             priv->shadow->destroy(priv->shadow);
  373.             priv->shadow = NULL;
  374.          }
  375.          if (priv->codec) {
  376.             priv->codec->destroy(priv->codec);
  377.             priv->codec = NULL;
  378.          }
  379.       }
  380.    }
  381.  
  382.    return omx_base_component_MessageHandler(comp, msg);
  383. }
  384.  
  385. void vid_dec_NeedTarget(vid_dec_PrivateType *priv)
  386. {
  387.    struct pipe_video_buffer templat = {};
  388.    omx_base_video_PortType *port;
  389.  
  390.    port = (omx_base_video_PortType *)priv->ports[OMX_BASE_FILTER_INPUTPORT_INDEX];
  391.  
  392.    if (!priv->target) {
  393.       templat.buffer_format = PIPE_FORMAT_NV12;
  394.       templat.chroma_format = PIPE_VIDEO_CHROMA_FORMAT_420;
  395.       templat.width = port->sPortParam.format.video.nFrameWidth;
  396.       templat.height = port->sPortParam.format.video.nFrameHeight;
  397.       templat.interlaced = false;
  398.       priv->target = priv->pipe->create_video_buffer(priv->pipe, &templat);
  399.    }
  400. }
  401.  
  402. static void vid_dec_FreeInputPortPrivate(OMX_BUFFERHEADERTYPE *buf)
  403. {
  404.    struct pipe_video_buffer *vbuf = buf->pInputPortPrivate;
  405.    if (!vbuf)
  406.       return;
  407.  
  408.    vbuf->destroy(vbuf);
  409.    buf->pInputPortPrivate = NULL;
  410. }
  411.  
  412. static OMX_ERRORTYPE vid_dec_DecodeBuffer(omx_base_PortType *port, OMX_BUFFERHEADERTYPE *buf)
  413. {
  414.    OMX_COMPONENTTYPE* comp = port->standCompContainer;
  415.    vid_dec_PrivateType *priv = comp->pComponentPrivate;
  416.    unsigned i = priv->num_in_buffers++;
  417.    OMX_ERRORTYPE r;
  418.  
  419.    priv->in_buffers[i] = buf;
  420.    priv->sizes[i] = buf->nFilledLen;
  421.    priv->inputs[i] = buf->pBuffer;
  422.  
  423.    while (priv->num_in_buffers > (!!(buf->nFlags & OMX_BUFFERFLAG_EOS) ? 0 : 1)) {
  424.       bool eos = !!(priv->in_buffers[0]->nFlags & OMX_BUFFERFLAG_EOS);
  425.       unsigned min_bits_left = eos ? 32 : MAX2(buf->nFilledLen * 8, 32);
  426.       struct vl_vlc vlc;
  427.  
  428.       vl_vlc_init(&vlc, priv->num_in_buffers, priv->inputs, priv->sizes);
  429.  
  430.       if (priv->slice)
  431.          priv->bytes_left = vl_vlc_bits_left(&vlc) / 8;
  432.  
  433.       while (vl_vlc_bits_left(&vlc) > min_bits_left) {
  434.          priv->Decode(priv, &vlc, min_bits_left);
  435.          vl_vlc_fillbits(&vlc);
  436.       }
  437.  
  438.       if (priv->slice) {
  439.          unsigned bytes = priv->bytes_left - vl_vlc_bits_left(&vlc) / 8;
  440.  
  441.          priv->codec->decode_bitstream(priv->codec, priv->target, &priv->picture.base,
  442.                                        1, &priv->slice, &bytes);
  443.  
  444.          if (priv->num_in_buffers)
  445.             priv->slice = priv->inputs[1];
  446.          else
  447.             priv->slice = NULL;
  448.       }
  449.  
  450.       if (eos && priv->frame_started)
  451.          priv->EndFrame(priv);
  452.  
  453.       if (priv->frame_finished) {
  454.          priv->frame_finished = false;
  455.          priv->in_buffers[0]->nFilledLen = priv->in_buffers[0]->nAllocLen;
  456.          r = base_port_SendBufferFunction(port, priv->in_buffers[0]);
  457.       } else if (eos) {
  458.          vid_dec_FreeInputPortPrivate(priv->in_buffers[0]);
  459.          priv->in_buffers[0]->nFilledLen = priv->in_buffers[0]->nAllocLen;
  460.          r = base_port_SendBufferFunction(port, priv->in_buffers[0]);
  461.       } else {
  462.          priv->in_buffers[0]->nFilledLen = 0;
  463.          r = port->ReturnBufferFunction(port, priv->in_buffers[0]);
  464.       }
  465.  
  466.       if (--priv->num_in_buffers) {
  467.          unsigned delta = MIN2((min_bits_left - vl_vlc_bits_left(&vlc)) / 8, priv->sizes[1]);
  468.  
  469.          priv->in_buffers[0] = priv->in_buffers[1];
  470.          priv->sizes[0] = priv->sizes[1] - delta;
  471.          priv->inputs[0] = priv->inputs[1] + delta;
  472.       }
  473.  
  474.       if (r)
  475.          return r;
  476.    }
  477.  
  478.    return OMX_ErrorNone;
  479. }
  480.  
  481. static OMX_ERRORTYPE vid_dec_FreeDecBuffer(omx_base_PortType *port, OMX_U32 idx, OMX_BUFFERHEADERTYPE *buf)
  482. {
  483.    vid_dec_FreeInputPortPrivate(buf);
  484.    return base_port_FreeBuffer(port, idx, buf);
  485. }
  486.  
  487. static void vid_dec_FillOutput(vid_dec_PrivateType *priv, struct pipe_video_buffer *buf,
  488.                                OMX_BUFFERHEADERTYPE* output)
  489. {
  490.    omx_base_PortType *port = priv->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX];
  491.    OMX_VIDEO_PORTDEFINITIONTYPE *def = &port->sPortParam.format.video;
  492.  
  493.    struct pipe_sampler_view **views;
  494.    struct pipe_transfer *transfer;
  495.    struct pipe_box box = { };
  496.    uint8_t *src, *dst;
  497.  
  498.    views = buf->get_sampler_view_planes(buf);
  499.  
  500.    dst = output->pBuffer;
  501.  
  502.    box.width = def->nFrameWidth;
  503.    box.height = def->nFrameHeight;
  504.    box.depth = 1;
  505.  
  506.    src = priv->pipe->transfer_map(priv->pipe, views[0]->texture, 0,
  507.                                   PIPE_TRANSFER_READ, &box, &transfer);
  508.    util_copy_rect(dst, views[0]->texture->format, def->nStride, 0, 0,
  509.                   box.width, box.height, src, transfer->stride, 0, 0);
  510.    pipe_transfer_unmap(priv->pipe, transfer);
  511.  
  512.    dst = ((uint8_t*)output->pBuffer) + (def->nStride * box.height);
  513.  
  514.    box.width = def->nFrameWidth / 2;
  515.    box.height = def->nFrameHeight / 2;
  516.  
  517.    src = priv->pipe->transfer_map(priv->pipe, views[1]->texture, 0,
  518.                                   PIPE_TRANSFER_READ, &box, &transfer);
  519.    util_copy_rect(dst, views[1]->texture->format, def->nStride, 0, 0,
  520.                   box.width, box.height, src, transfer->stride, 0, 0);
  521.    pipe_transfer_unmap(priv->pipe, transfer);
  522. }
  523.  
  524. static void vid_dec_FrameDecoded(OMX_COMPONENTTYPE *comp, OMX_BUFFERHEADERTYPE* input,
  525.                                  OMX_BUFFERHEADERTYPE* output)
  526. {
  527.    vid_dec_PrivateType *priv = comp->pComponentPrivate;
  528.    bool eos = !!(input->nFlags & OMX_BUFFERFLAG_EOS);
  529.  
  530.    if (!input->pInputPortPrivate)
  531.       input->pInputPortPrivate = priv->Flush(priv);
  532.  
  533.    if (input->pInputPortPrivate) {
  534.       if (output->pInputPortPrivate) {
  535.          struct pipe_video_buffer *tmp = output->pOutputPortPrivate;
  536.          output->pOutputPortPrivate = input->pInputPortPrivate;
  537.          input->pInputPortPrivate = tmp;
  538.       } else {
  539.          vid_dec_FillOutput(priv, input->pInputPortPrivate, output);
  540.       }
  541.       output->nFilledLen = output->nAllocLen;
  542.    }
  543.  
  544.    if (eos && input->pInputPortPrivate)
  545.       vid_dec_FreeInputPortPrivate(input);
  546.    else
  547.       input->nFilledLen = 0;
  548. }
  549.