Home | History | Annotate | Download | only in src
      1 /*
      2  * Copyright (c) 2011 Intel Corporation. All Rights Reserved.
      3  * Copyright (c) Imagination Technologies Limited, UK
      4  *
      5  * Permission is hereby granted, free of charge, to any person obtaining a
      6  * copy of this software and associated documentation files (the
      7  * "Software"), to deal in the Software without restriction, including
      8  * without limitation the rights to use, copy, modify, merge, publish,
      9  * distribute, sub license, and/or sell copies of the Software, and to
     10  * permit persons to whom the Software is furnished to do so, subject to
     11  * the following conditions:
     12  *
     13  * The above copyright notice and this permission notice (including the
     14  * next paragraph) shall be included in all copies or substantial portions
     15  * of the Software.
     16  *
     17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
     18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
     19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
     20  * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
     21  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
     22  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
     23  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
     24  *
     25  * Authors:
     26  *    Waldo Bastian <waldo.bastian (at) intel.com>
     27  *
     28  */
     29 
     30 #include <sys/types.h>
     31 #include "psb_buffer.h"
     32 
     33 #include <errno.h>
     34 #include <stdlib.h>
     35 #include <unistd.h>
     36 #include <wsbm/wsbm_manager.h>
     37 
     38 #ifdef ANDROID
     39 #ifdef BAYTRAIL
     40 #include <linux/vxd_drm.h>
     41 #else
     42 #include <drm/ttm/ttm_placement.h>
     43 #include <linux/psb_drm.h>
     44 #endif
     45 #else
     46 #include <psb_drm.h>
     47 #endif
     48 
     49 #include "psb_def.h"
     50 #include "psb_drv_debug.h"
     51 #include "tng_cmdbuf.h"
     52 
     53 #ifndef BAYTRAIL
     54 #include <pnw_cmdbuf.h>
     55 #include "pnw_jpeg.h"
     56 #include "pnw_H264ES.h"
     57 #include "tng_jpegES.h"
     58 #endif
     59 
     60 #include "vsp_fw.h"
     61 /*
     62  * Create buffer
     63  */
     64 VAStatus psb_buffer_create(psb_driver_data_p driver_data,
     65                            unsigned int size,
     66                            psb_buffer_type_t type,
     67                            psb_buffer_p buf
     68                           )
     69 {
     70     VAStatus vaStatus = VA_STATUS_SUCCESS;
     71     int allignment;
     72     uint32_t placement;
     73     int ret;
     74 
     75     /* reset rar_handle to NULL */
     76     buf->rar_handle = 0;
     77     buf->buffer_ofs = 0;
     78 
     79     buf->type = type;
     80     buf->driver_data = driver_data; /* only for RAR buffers */
     81     buf->size = size;
     82     /* TODO: Mask values are a guess */
     83     switch (type) {
     84     case psb_bt_cpu_vpu:
     85         allignment = 1;
     86         placement = DRM_PSB_FLAG_MEM_MMU;
     87         break;
     88     case psb_bt_cpu_vpu_shared:
     89         allignment = 1;
     90         placement = DRM_PSB_FLAG_MEM_MMU | WSBM_PL_FLAG_SHARED;
     91         break;
     92     case psb_bt_surface:
     93         allignment = 0;
     94         placement = DRM_PSB_FLAG_MEM_MMU | WSBM_PL_FLAG_SHARED;
     95         if (IS_CTP(driver_data))  /* CTP support cache snoop */
     96             placement |= WSBM_PL_FLAG_CACHED;
     97         break;
     98     case psb_bt_surface_tt:
     99         allignment = 0;
    100         placement = WSBM_PL_FLAG_TT | WSBM_PL_FLAG_NO_EVICT | WSBM_PL_FLAG_SHARED;
    101         break;
    102 #ifdef PSBVIDEO_MSVDX_DEC_TILING
    103     case psb_bt_surface_tiling:
    104             drv_debug_msg(VIDEO_DEBUG_GENERAL, "Allocate tiled surface from TT heap\n");
    105             placement =  WSBM_PL_FLAG_TT | WSBM_PL_FLAG_SHARED;
    106             allignment = 2048 * 16; /* Tiled row aligned */
    107         break;
    108     case psb_bt_mmu_tiling:
    109             placement =  DRM_PSB_FLAG_MEM_MMU_TILING | WSBM_PL_FLAG_SHARED;
    110             allignment = 2048 * 16; /* Tiled row aligned */
    111         break;
    112 #endif
    113     case psb_bt_cpu_vpu_cached:
    114         allignment = 1;
    115         placement = DRM_PSB_FLAG_MEM_MMU | WSBM_PL_FLAG_CACHED;
    116         break;
    117     case psb_bt_vpu_only:
    118         allignment = 1;
    119         placement = DRM_PSB_FLAG_MEM_MMU;
    120         break;
    121     case psb_bt_cpu_only:
    122         allignment = 1;
    123         placement = WSBM_PL_FLAG_SYSTEM | WSBM_PL_FLAG_CACHED;
    124         break;
    125 #if PSB_MFLD_DUMMY_CODE
    126     case psb_bt_camera:
    127         allignment = 1;
    128         placement = WSBM_PL_FLAG_SHARED;
    129         break;
    130 #endif
    131 #ifdef ANDROID
    132 #ifndef BAYTRAIL
    133     case psb_bt_imr:
    134         allignment = 1;
    135         placement = TTM_PL_FLAG_IMR | WSBM_PL_FLAG_SHARED;
    136         break;
    137 #endif
    138 #endif
    139     default:
    140         vaStatus = VA_STATUS_ERROR_UNKNOWN;
    141         DEBUG_FAILURE;
    142         return vaStatus;
    143     }
    144     ret = LOCK_HARDWARE(driver_data);
    145     if (ret) {
    146         UNLOCK_HARDWARE(driver_data);
    147         vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
    148         DEBUG_FAILURE_RET;
    149         return vaStatus;
    150     }
    151 
    152 #ifdef VA_EMULATOR
    153     placement |= WSBM_PL_FLAG_SHARED;
    154 #endif
    155 
    156 #ifndef ANDROID
    157     if(!(placement & WSBM_PL_FLAG_SYSTEM)) {
    158         //drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: buffer->pl_flags 0x%08x\n", __func__, placement);
    159         placement &= ~WSBM_PL_MASK_MEM;
    160         placement &= ~WSBM_PL_FLAG_NO_EVICT;
    161         placement |= TTM_PL_FLAG_VRAM;
    162         //drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: repleace buffer->pl_flags 0x%08x\n", __func__, placement);
    163     }
    164 #endif
    165 
    166 #ifdef MSVDX_VA_EMULATOR
    167     placement |= WSBM_PL_FLAG_SHARED;
    168 #endif
    169 
    170     if(allignment < 4096)
    171         allignment = 4096; /* temporily more safe */
    172 
    173     //drv_debug_msg(VIDEO_DEBUG_ERROR, "FIXME: should use geetpagesize() ?\n");
    174     ret = wsbmGenBuffers(driver_data->main_pool, 1, &buf->drm_buf,
    175                          allignment, placement);
    176     if (!buf->drm_buf) {
    177         drv_debug_msg(VIDEO_DEBUG_ERROR, "failed to gen wsbm buffers\n");
    178         UNLOCK_HARDWARE(driver_data);
    179         return VA_STATUS_ERROR_ALLOCATION_FAILED;
    180     }
    181 
    182     /* here use the placement when gen buffer setted */
    183     ret = wsbmBOData(buf->drm_buf, size, NULL, NULL, 0);
    184     UNLOCK_HARDWARE(driver_data);
    185     if (ret) {
    186         drv_debug_msg(VIDEO_DEBUG_ERROR, "failed to alloc wsbm buffers\n");
    187         return VA_STATUS_ERROR_ALLOCATION_FAILED;
    188     }
    189 
    190     if (placement & WSBM_PL_FLAG_TT)
    191         drv_debug_msg(VIDEO_DEBUG_GENERAL, "Create BO with TT placement (%d byte),BO GPU offset hint=0x%08x\n",
    192                                  size, wsbmBOOffsetHint(buf->drm_buf));
    193 
    194     buf->pl_flags = placement;
    195     buf->status = psb_bs_ready;
    196     buf->wsbm_synccpu_flag = 0;
    197 
    198     return VA_STATUS_SUCCESS;
    199 }
    200 
    201 /*
    202  * Create buffer
    203  */
    204 VAStatus psb_buffer_create_from_ub(psb_driver_data_p driver_data,
    205                            unsigned int size,
    206                            psb_buffer_type_t type,
    207                            psb_buffer_p buf,
    208                            void * vaddr,
    209                            int fd,
    210                            unsigned int flags
    211                           )
    212 {
    213     VAStatus vaStatus = VA_STATUS_SUCCESS;
    214     int allignment;
    215     uint32_t placement;
    216     int ret;
    217 
    218     /* reset rar_handle to NULL */
    219     buf->rar_handle = 0;
    220     buf->buffer_ofs = 0;
    221 
    222     buf->type = type;
    223     buf->driver_data = driver_data; /* only for RAR buffers */
    224     buf->user_ptr = vaddr;
    225     buf->fd = fd;
    226 
    227     /* Xvideo will share surface buffer, set SHARED flag
    228     */
    229     placement =  DRM_PSB_FLAG_MEM_MMU | WSBM_PL_FLAG_SHARED ;
    230 
    231     ret = LOCK_HARDWARE(driver_data);
    232     if (ret) {
    233         UNLOCK_HARDWARE(driver_data);
    234         vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
    235         DEBUG_FAILURE_RET;
    236         return vaStatus;
    237     }
    238 
    239     allignment = 4096; /* temporily more safe */
    240 #ifdef PSBVIDEO_MSVDX_DEC_TILING
    241     if (type == psb_bt_mmu_tiling) {
    242         placement =  DRM_PSB_FLAG_MEM_MMU_TILING | WSBM_PL_FLAG_SHARED ;
    243         allignment = 2048 * 16; /* Tiled row aligned */
    244     }
    245 #endif
    246 
    247     if (flags & PSB_USER_BUFFER_WC)
    248 	placement |= WSBM_PL_FLAG_WC;
    249     else if (flags & PSB_USER_BUFFER_UNCACHED)
    250 	placement |= WSBM_PL_FLAG_UNCACHED;
    251     else
    252 	placement |= WSBM_PL_FLAG_CACHED;
    253 
    254     //drv_debug_msg(VIDEO_DEBUG_ERROR, "FIXME: should use geetpagesize() ?\n");
    255     ret = wsbmGenBuffers(driver_data->main_pool, 1, &buf->drm_buf,
    256     allignment, placement);
    257     if (!buf->drm_buf) {
    258         drv_debug_msg(VIDEO_DEBUG_ERROR, "failed to gen wsbm buffers\n");
    259         UNLOCK_HARDWARE(driver_data);
    260         return VA_STATUS_ERROR_ALLOCATION_FAILED;
    261     }
    262 
    263     /* here use the placement when gen buffer setted */
    264     drv_debug_msg(VIDEO_DEBUG_GENERAL, "Create BO from user buffer %p, size=%d, fd = %d\n", vaddr, size, fd);
    265 
    266     ret = wsbmBODataUB(buf->drm_buf, size, NULL, NULL, 0, vaddr, fd);
    267     if (ret) {
    268         drv_debug_msg(VIDEO_DEBUG_ERROR, "Failed to alloc wsbm buffers, buf->drm_buf is 0x%x, size is %d, vaddr is 0x%x, fd=%d\n", buf->drm_buf, size, vaddr, fd);
    269         return 1;
    270     }
    271 
    272     drv_debug_msg(VIDEO_DEBUG_GENERAL, "Create BO from user buffer 0x%08x (%d byte), fd=%d, BO GPU offset hint=0x%08x\n",
    273     vaddr, size, fd, wsbmBOOffsetHint(buf->drm_buf));
    274 
    275     buf->pl_flags = placement;
    276     buf->status = psb_bs_ready;
    277     buf->wsbm_synccpu_flag = 0;
    278 
    279     return VA_STATUS_SUCCESS;
    280 }
    281 
    282 #if 0
    283 /*
    284  * buffer setstatus
    285  *
    286  * Returns 0 on success
    287  */
    288 int psb_buffer_setstatus(psb_buffer_p buf, uint32_t set_placement, uint32_t clr_placement)
    289 {
    290     int ret = 0;
    291 
    292     ASSERT(buf);
    293     ASSERT(buf->driver_data);
    294 
    295     ret = wsbmBOSetStatus(buf->drm_buf, set_placement, clr_placement);
    296     if (ret == 0)
    297         buf->pl_flags = set_placement;
    298 
    299     return ret;
    300 }
    301 #endif
    302 
    303 VAStatus psb_buffer_reference(psb_driver_data_p driver_data,
    304                               psb_buffer_p buf,
    305                               psb_buffer_p reference_buf
    306                              )
    307 {
    308     int ret = 0;
    309     VAStatus vaStatus = VA_STATUS_SUCCESS;
    310 
    311     memcpy(buf, reference_buf, sizeof(*buf));
    312     buf->drm_buf = NULL;
    313 
    314     ret = LOCK_HARDWARE(driver_data);
    315     if (ret) {
    316         UNLOCK_HARDWARE(driver_data);
    317         vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
    318         DEBUG_FAILURE_RET;
    319         return vaStatus;
    320     }
    321 
    322     ret = wsbmGenBuffers(driver_data->main_pool,
    323                          1,
    324                          &buf->drm_buf,
    325                          4096,  /* page alignment */
    326                          0);
    327     if (!buf->drm_buf) {
    328         drv_debug_msg(VIDEO_DEBUG_ERROR, "failed to gen wsbm buffers\n");
    329         UNLOCK_HARDWARE(driver_data);
    330         return VA_STATUS_ERROR_ALLOCATION_FAILED;
    331     }
    332 
    333     ret = wsbmBOSetReferenced(buf->drm_buf, wsbmKBufHandle(wsbmKBuf(reference_buf->drm_buf)));
    334     UNLOCK_HARDWARE(driver_data);
    335     if (ret) {
    336         drv_debug_msg(VIDEO_DEBUG_ERROR, "failed to alloc wsbm buffers\n");
    337         return VA_STATUS_ERROR_ALLOCATION_FAILED;
    338     }
    339 
    340     return VA_STATUS_SUCCESS;
    341 }
    342 
    343 VAStatus psb_kbuffer_reference(psb_driver_data_p driver_data,
    344                                psb_buffer_p buf,
    345                                int kbuf_handle
    346                               )
    347 {
    348     int ret = 0;
    349     VAStatus vaStatus = VA_STATUS_SUCCESS;
    350 
    351     buf->drm_buf = NULL;
    352 
    353     ret = LOCK_HARDWARE(driver_data);
    354     if (ret) {
    355         UNLOCK_HARDWARE(driver_data);
    356         vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
    357         DEBUG_FAILURE_RET;
    358         return vaStatus;
    359     }
    360 
    361     ret = wsbmGenBuffers(driver_data->main_pool,
    362                          1,
    363                          &buf->drm_buf,
    364                          4096,  /* page alignment */
    365                          0);
    366     if (!buf->drm_buf) {
    367         drv_debug_msg(VIDEO_DEBUG_ERROR, "failed to gen wsbm buffers\n");
    368         UNLOCK_HARDWARE(driver_data);
    369         return VA_STATUS_ERROR_ALLOCATION_FAILED;
    370     }
    371 
    372     ret = wsbmBOSetReferenced(buf->drm_buf, kbuf_handle);
    373     UNLOCK_HARDWARE(driver_data);
    374     if (ret) {
    375         drv_debug_msg(VIDEO_DEBUG_ERROR, "failed to alloc wsbm buffers\n");
    376         return VA_STATUS_ERROR_ALLOCATION_FAILED;
    377     }
    378     buf->pl_flags = wsbmBOPlacementHint(buf->drm_buf);
    379     buf->type = psb_bt_surface;
    380     buf->status = psb_bs_ready;
    381 
    382     return VA_STATUS_SUCCESS;
    383 }
    384 /*
    385  * Destroy buffer
    386  */
    387 void psb_buffer_destroy(psb_buffer_p buf)
    388 {
    389     ASSERT(buf);
    390     if (buf->drm_buf == NULL)
    391         return;
    392     if (psb_bs_unfinished != buf->status) {
    393         ASSERT(buf->driver_data);
    394         wsbmBOUnreference(&buf->drm_buf);
    395         if (buf->rar_handle)
    396             buf->rar_handle = 0;
    397         buf->driver_data = NULL;
    398         buf->status = psb_bs_unfinished;
    399     }
    400 }
    401 
    402 /*
    403  * Map buffer
    404  *
    405  * Returns 0 on success
    406  */
    407 int psb_buffer_map(psb_buffer_p buf, unsigned char **address /* out */)
    408 {
    409     int ret;
    410 
    411     ASSERT(buf);
    412     ASSERT(buf->driver_data);
    413 
    414     /* multiple mapping not allowed */
    415     if (buf->wsbm_synccpu_flag) {
    416         drv_debug_msg(VIDEO_DEBUG_GENERAL, "Multiple mapping request detected, unmap previous mapping\n");
    417         drv_debug_msg(VIDEO_DEBUG_GENERAL, "Need to fix application to unmap at first, then request second mapping request\n");
    418 
    419         psb_buffer_unmap(buf);
    420     }
    421 
    422     /* don't think TG deal with READ/WRITE differently */
    423     buf->wsbm_synccpu_flag = WSBM_SYNCCPU_READ | WSBM_SYNCCPU_WRITE;
    424     if (psb_video_trace_fp) {
    425         wsbmBOWaitIdle(buf->drm_buf, 0);
    426     } else {
    427         ret = wsbmBOSyncForCpu(buf->drm_buf, buf->wsbm_synccpu_flag);
    428         if (ret) {
    429             drv_debug_msg(VIDEO_DEBUG_ERROR, "faild to sync bo for cpu\n");
    430             return ret;
    431         }
    432     }
    433 
    434     if (buf->user_ptr) /* user mode buffer */
    435         *address = buf->user_ptr;
    436     else
    437         *address = wsbmBOMap(buf->drm_buf, buf->wsbm_synccpu_flag);
    438 
    439     if (*address == NULL) {
    440         drv_debug_msg(VIDEO_DEBUG_ERROR, "failed to map buffer\n");
    441         return -1;
    442     }
    443 
    444     return 0;
    445 }
    446 
    447 /*
    448  * Unmap buffer
    449  *
    450  * Returns 0 on success
    451  */
    452 int psb_buffer_unmap(psb_buffer_p buf)
    453 {
    454     ASSERT(buf);
    455     ASSERT(buf->driver_data);
    456 
    457     if (buf->wsbm_synccpu_flag)
    458         (void) wsbmBOReleaseFromCpu(buf->drm_buf, buf->wsbm_synccpu_flag);
    459 
    460     buf->wsbm_synccpu_flag = 0;
    461 
    462     if ((buf->type != psb_bt_user_buffer) && !buf->handle)
    463         wsbmBOUnmap(buf->drm_buf);
    464 
    465     return 0;
    466 }
    467 
    468 #define _MRFL_DEBUG_CODED_
    469 
    470 #ifdef _MRFL_DEBUG_CODED_
    471 static void psb__trace_coded(VACodedBufferSegment *vaCodedBufSeg)
    472 {
    473     int i, j;
    474     int uiPipeIndex = -1;
    475     unsigned int *pBuf = NULL;
    476     do {
    477         ++uiPipeIndex;
    478         drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: pipe num %d, size = %d\n", __FUNCTION__, uiPipeIndex, vaCodedBufSeg[uiPipeIndex].size);
    479         pBuf = (unsigned int *)(vaCodedBufSeg[uiPipeIndex].buf);
    480         pBuf -= 16;
    481         for (i = 0; i < 6; i++) {
    482             for (j = 0; j < 4; j++) {
    483                 drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: 0x%08x\n", __FUNCTION__, pBuf[(i*4) + j]);
    484             }
    485          }
    486         drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: \n", __FUNCTION__);
    487     } while (vaCodedBufSeg[uiPipeIndex].next);
    488 
    489 	return ;
    490 }
    491 #endif
    492 
    493 #define PROFILE_H264(profile) ((profile>=VAProfileH264Baseline && profile <=VAProfileH264High) || \
    494                                (profile == VAProfileH264ConstrainedBaseline))
    495 static void tng_get_coded_data(
    496     object_buffer_p obj_buffer,
    497     unsigned char *raw_codedbuf
    498 )
    499 {
    500     object_context_p obj_context = obj_buffer->context;
    501     VACodedBufferSegment *vaCodedBufSeg = &obj_buffer->codedbuf_mapinfo[0];
    502     int iPipeIndex = 0;
    503     unsigned int uiPipeNum = tng_get_pipe_number(obj_context);
    504     unsigned int uiBufOffset = tng_align_KB(obj_buffer->size >> 1);
    505     unsigned long *ptmp = NULL;
    506     int tmp;
    507 
    508     drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s pipenum = 0x%x\n", __FUNCTION__, uiPipeNum);
    509     drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s offset  = 0x%x\n", __FUNCTION__, uiBufOffset);
    510 
    511     tmp = vaCodedBufSeg[iPipeIndex].size = *(unsigned int *)((unsigned long)raw_codedbuf);
    512 
    513     /*
    514      * This is used for DRM over WiDi which only uses H264 BP
    515      * Tangier IED encryption operates on the chunks with 16bytes, and we must include
    516      * the extra bytes beyond slice data as a whole chunk for decrption
    517      * We simply include the padding bytes regardless of IED enable or disable
    518      */
    519     if (PROFILE_H264(obj_context->profile) && (tmp % 16 != 0)) {
    520 	tmp = (tmp + 15) & (~15);
    521 	drv_debug_msg(VIDEO_DEBUG_GENERAL, "Force slice size from %d to %d\n",
    522                       vaCodedBufSeg[iPipeIndex].size, tmp);
    523 	vaCodedBufSeg[iPipeIndex].size  = tmp;
    524     }
    525 
    526     vaCodedBufSeg[iPipeIndex].buf = (unsigned char *)(((unsigned int *)((unsigned long)raw_codedbuf)) + 16); /* skip 4DWs */
    527 
    528     ptmp = (unsigned long *)((unsigned long)raw_codedbuf);
    529     vaCodedBufSeg[iPipeIndex].reserved = (ptmp[1] >> 6) & 0xf;
    530     vaCodedBufSeg[iPipeIndex].next = NULL;
    531 
    532 
    533     if (uiPipeNum == 2) {
    534         /*The second part of coded buffer which generated by core 2 is the
    535          * first part of encoded clip, while the first part of coded buffer
    536          * is the second part of encoded clip.*/
    537         ++iPipeIndex;
    538         vaCodedBufSeg[iPipeIndex - 1].next = &vaCodedBufSeg[iPipeIndex];
    539         tmp = vaCodedBufSeg[iPipeIndex].size = *(unsigned int *)((unsigned long)raw_codedbuf + uiBufOffset);
    540 
    541         /*
    542          * This is used for DRM over WiDi which only uses H264 BP
    543          * Tangier IED encryption operates on the chunks with 16bytes, and we must include
    544          * the extra bytes beyond slice data as a whole chunk for decryption
    545          * We simply include the padding bytes regardless of IED enable or disable
    546          */
    547         if (PROFILE_H264(obj_context->profile) && (tmp % 16 != 0)) {
    548             tmp = (tmp + 15) & (~15);
    549             drv_debug_msg(VIDEO_DEBUG_GENERAL,"Force slice size from %d to %d\n",
    550                           vaCodedBufSeg[iPipeIndex].size, tmp);
    551 
    552             vaCodedBufSeg[iPipeIndex].size  = tmp;
    553         }
    554 
    555         vaCodedBufSeg[iPipeIndex].buf = (unsigned char *)(((unsigned int *)((unsigned long)raw_codedbuf + uiBufOffset)) + 16); /* skip 4DWs */
    556         vaCodedBufSeg[iPipeIndex].reserved = vaCodedBufSeg[iPipeIndex - 1].reserved;
    557         vaCodedBufSeg[iPipeIndex].next = NULL;
    558     }
    559 
    560 #ifdef _MRFL_DEBUG_CODED_
    561     psb__trace_coded(vaCodedBufSeg);
    562 #endif
    563 
    564     return ;
    565 }
    566 
    567 /*
    568  * Return special data structure for codedbuffer
    569  *
    570  * Returns 0 on success
    571  */
    572 #define CONFIG(id)  ((object_config_p) object_heap_lookup( &driver_data->config_heap, id ))
    573 #define INIT_DRIVER_DATA    psb_driver_data_p driver_data = (psb_driver_data_p) ctx->pDriverData;
    574 int psb_codedbuf_map_mangle(
    575     VADriverContextP ctx,
    576     object_buffer_p obj_buffer,
    577     void **pbuf /* out */
    578 )
    579 {
    580     object_context_p obj_context = obj_buffer->context;
    581     INIT_DRIVER_DATA;
    582     VACodedBufferSegment *p = &obj_buffer->codedbuf_mapinfo[0];
    583     unsigned char *raw_codedbuf;
    584     VAStatus vaStatus = VA_STATUS_SUCCESS;
    585     unsigned int next_buf_off;
    586     uint32_t i;
    587 
    588     CHECK_INVALID_PARAM(pbuf == NULL);
    589 
    590     if (NULL == obj_context) {
    591         vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
    592         DEBUG_FAILURE;
    593 
    594         psb_buffer_unmap(obj_buffer->psb_buffer);
    595         obj_buffer->buffer_data = NULL;
    596 
    597         return vaStatus;
    598     }
    599 
    600     raw_codedbuf = *pbuf;
    601     /* reset the mapinfo */
    602     memset(obj_buffer->codedbuf_mapinfo, 0, sizeof(obj_buffer->codedbuf_mapinfo));
    603 
    604     *pbuf = p = &obj_buffer->codedbuf_mapinfo[0];
    605 #ifdef PSBVIDEO_MRFL
    606     if (IS_MRFL(driver_data)) {
    607         object_config_p obj_config = CONFIG(obj_context->config_id);
    608         if (NULL == obj_config) {
    609             vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
    610             DEBUG_FAILURE;
    611 
    612             psb_buffer_unmap(obj_buffer->psb_buffer);
    613             obj_buffer->buffer_data = NULL;
    614 
    615             return vaStatus;
    616         }
    617 
    618         if (VAProfileJPEGBaseline != obj_config->profile
    619             && (*((unsigned long *) raw_codedbuf + 1) & SKIP_NEXT_FRAME) != 0) {
    620             /*Set frame skip flag*/
    621             tng_set_frame_skip_flag(obj_context);
    622         }
    623         switch (obj_config->profile) {
    624             case VAProfileMPEG4Simple:
    625             case VAProfileMPEG4AdvancedSimple:
    626             case VAProfileMPEG4Main:
    627 
    628             case VAProfileH264Baseline:
    629             case VAProfileH264Main:
    630             case VAProfileH264High:
    631             case VAProfileH264StereoHigh:
    632             case VAProfileH264ConstrainedBaseline:
    633             case VAProfileH263Baseline:
    634                 /* 1st segment */
    635                 tng_get_coded_data(obj_buffer, raw_codedbuf);
    636 #if 0
    637                 p->size = *((unsigned long *) raw_codedbuf);
    638                 p->buf = (unsigned char *)((unsigned long *) raw_codedbuf + 16); /* skip 16DWs */
    639                 p->next = NULL;
    640 #ifdef _MRFL_DEBUG_CODED_
    641                 psb__trace_coded((unsigned int*)raw_codedbuf);
    642                 psb__trace_coded(p);
    643 #endif
    644 #endif
    645                 break;
    646             case VAProfileVP8Version0_3:
    647             {
    648                 /* multi segments*/
    649 		struct VssVp8encEncodedFrame *t = (struct VssVp8encEncodedFrame *) (raw_codedbuf);
    650 		int concatenate = 1;
    651 #if 0
    652 		for (i = 0; i < t->partitions - 1; i++) {
    653                     if (t->partition_start[i+1] != t->partition_start[i] + t->partition_size[i])
    654                         concatenate = 0;
    655 		}
    656 #endif
    657 		/* reference frame surface_id */
    658                 /* default is recon_buffer_mode ==0 */
    659                 p->reserved = t->surfaceId_of_ref_frame[3];
    660 
    661 		if (concatenate) {
    662                     /* partitions are concatenate */
    663                     p->buf = t->coded_data;
    664                     p->size = t->frame_size;
    665                     if(t->frame_size == 0){
    666                         drv_debug_msg(VIDEO_DEBUG_ERROR,"Frame size is zero, Force it to 3, encoder status is 0x%x\n", t->status);
    667                         p->size = 3;
    668                         t->coded_data[0]=0;
    669                     }
    670                     p->next = NULL;
    671 		} else {
    672                     for (i = 0; i < t->partitions; i++) {
    673                         /* partition not consecutive */
    674                         p->buf = t->coded_data + t->partition_start[i] - t->partition_start[0];
    675                         p->size += t->partition_size[i];
    676                         p->next = &p[1];
    677                         p++;
    678 		    }
    679 		    p--;
    680 		    p->next = NULL;
    681 		}
    682 
    683 		break;
    684             }
    685             case VAProfileJPEGBaseline:
    686                 /* 3~6 segment */
    687                 tng_jpeg_AppendMarkers(obj_context, raw_codedbuf);
    688                 next_buf_off = 0;
    689                 /*Max resolution 4096x4096 use 6 segments*/
    690                 for (i = 0; i < PTG_JPEG_MAX_SCAN_NUM + 1; i++) {
    691                     p->size = *(unsigned long *)((unsigned long)raw_codedbuf + next_buf_off);  /* ui32BytesUsed in HEADER_BUFFER*/
    692                     p->buf = (unsigned char *)((unsigned long *)((unsigned long)raw_codedbuf + next_buf_off) + 4);  /* skip 4DWs (HEADER_BUFFER) */
    693                     next_buf_off = *((unsigned long *)((unsigned long)raw_codedbuf + next_buf_off) + 3);  /* ui32Reserved3 in HEADER_BUFFER*/
    694 
    695                     drv_debug_msg(VIDEO_DEBUG_GENERAL, "JPEG coded buffer segment %d size: %d\n", i, p->size);
    696                     drv_debug_msg(VIDEO_DEBUG_GENERAL, "JPEG coded buffer next segment %d offset: %d\n", i + 1, next_buf_off);
    697 
    698                     if (next_buf_off == 0) {
    699                         p->next = NULL;
    700                         break;
    701                     } else
    702                         p->next = &p[1];
    703                     p++;
    704                 }
    705                 break;
    706 
    707             default:
    708                 drv_debug_msg(VIDEO_DEBUG_ERROR, "unexpected case\n");
    709 
    710                 psb_buffer_unmap(obj_buffer->psb_buffer);
    711                 obj_buffer->buffer_data = NULL;
    712                 break;
    713         }
    714     }
    715 #endif
    716 #ifdef PSBVIDEO_MFLD
    717     if (IS_MFLD(driver_data)){ /* MFLD */
    718         object_config_p obj_config = CONFIG(obj_context->config_id);
    719 
    720         if (NULL == obj_config) {
    721             vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
    722             DEBUG_FAILURE;
    723 
    724             psb_buffer_unmap(obj_buffer->psb_buffer);
    725             obj_buffer->buffer_data = NULL;
    726 
    727             return vaStatus;
    728         }
    729 
    730         if (VAProfileJPEGBaseline != obj_config->profile
    731             && (*((unsigned long *) raw_codedbuf + 1) & SKIP_NEXT_FRAME) != 0) {
    732             /*Set frame skip flag*/
    733             pnw_set_frame_skip_flag(obj_context);
    734         }
    735         switch (obj_config->profile) {
    736         case VAProfileMPEG4Simple:
    737         case VAProfileMPEG4AdvancedSimple:
    738         case VAProfileMPEG4Main:
    739             /* one segment */
    740             p->size = *((unsigned long *) raw_codedbuf);
    741             p->buf = (unsigned char *)((unsigned long *) raw_codedbuf + 4); /* skip 4DWs */
    742             drv_debug_msg(VIDEO_DEBUG_GENERAL, "coded buffer size %d\n", p->size);
    743             break;
    744 
    745         case VAProfileH264Baseline:
    746         case VAProfileH264Main:
    747         case VAProfileH264High:
    748         case VAProfileH264ConstrainedBaseline:
    749             i = 0;
    750             next_buf_off = ~0xf & (obj_buffer->size / pnw_get_parallel_core_number(obj_context));
    751             if (pnw_get_parallel_core_number(obj_context) == 2) {
    752                 /*The second part of coded buffer which generated by core 2 is the
    753                  * first part of encoded clip, while the first part of coded buffer
    754                  * is the second part of encoded clip.*/
    755                 p[i].next = &p[i + 1];
    756                 p[i].size = *(unsigned long *)((unsigned long)raw_codedbuf + next_buf_off);
    757                 p[i].buf = (unsigned char *)(((unsigned long *)((unsigned long)raw_codedbuf + next_buf_off)) + 4); /* skip 4DWs */
    758 
    759                 if (GET_CODEDBUF_INFO(SLICE_NUM, obj_buffer->codedbuf_aux_info) <= 2 &&
    760                         GET_CODEDBUF_INFO(NONE_VCL_NUM, obj_buffer->codedbuf_aux_info) == 0) {
    761                     p[i].status =  VA_CODED_BUF_STATUS_SINGLE_NALU;
    762                     drv_debug_msg(VIDEO_DEBUG_GENERAL, "Only VCL NAL in this segment %i of coded buffer\n",
    763                             i);
    764                 }
    765                 drv_debug_msg(VIDEO_DEBUG_GENERAL, "2nd segment coded buffer offset: 0x%08x,  size: %d\n",
    766                         next_buf_off, p[i].size);
    767 
    768               i++;
    769 
    770             }
    771             /* 1st segment */
    772             p[i].size = *((unsigned long *) raw_codedbuf);
    773             p[i].buf = (unsigned char *)((unsigned long *) raw_codedbuf + 4); /* skip 4DWs */
    774             drv_debug_msg(VIDEO_DEBUG_GENERAL, "1st segment coded buffer size %d\n", p[i].size);
    775             if (GET_CODEDBUF_INFO(SLICE_NUM, obj_buffer->codedbuf_aux_info) <= 2 &&
    776                     GET_CODEDBUF_INFO(NONE_VCL_NUM, obj_buffer->codedbuf_aux_info) == 0) {
    777                 p[i].status =  VA_CODED_BUF_STATUS_SINGLE_NALU;
    778                 drv_debug_msg(VIDEO_DEBUG_GENERAL, "Only VCL NAL in this segment %i of coded buffer\n",
    779                         i);
    780             }
    781             for (i = 0; i < pnw_get_parallel_core_number(obj_context); i++) {
    782                 if (p[i].size > (next_buf_off - sizeof(unsigned long) * 4)) {
    783                     drv_debug_msg(VIDEO_DEBUG_ERROR, "Coded segment %d is too large(%d)"
    784                             " and exceed segment boundary(offset %d)", i, p[i].size, next_buf_off);
    785                     p[i].size = next_buf_off - sizeof(unsigned long) * 4;
    786                 }
    787             }
    788 
    789             break;
    790 
    791         case VAProfileH263Baseline:
    792                 /* one segment */
    793             p->size = *((unsigned long *) raw_codedbuf);
    794             p->buf = (unsigned char *)((unsigned long *) raw_codedbuf + 4); /* skip 4DWs */
    795             drv_debug_msg(VIDEO_DEBUG_GENERAL, "coded buffer size %d\n", p->size);
    796             break;
    797 
    798         case VAProfileJPEGBaseline:
    799             /* 3~6 segment
    800                  */
    801             pnw_jpeg_AppendMarkers(obj_context, raw_codedbuf);
    802             next_buf_off = 0;
    803             /*Max resolution 4096x4096 use 6 segments*/
    804             for (i = 0; i < PNW_JPEG_MAX_SCAN_NUM + 1; i++) {
    805                 p->size = *(unsigned long *)((unsigned long)raw_codedbuf + next_buf_off);
    806                 p->buf = (unsigned char *)((unsigned long *)((unsigned long)raw_codedbuf + next_buf_off) + 4);  /* skip 4DWs */
    807                 next_buf_off = *((unsigned long *)((unsigned long)raw_codedbuf + next_buf_off) + 3);
    808 
    809                 drv_debug_msg(VIDEO_DEBUG_GENERAL, "JPEG coded buffer segment %d size: %d\n", i, p->size);
    810                 drv_debug_msg(VIDEO_DEBUG_GENERAL, "JPEG coded buffer next segment %d offset: %d\n", i + 1, next_buf_off);
    811 
    812                 if (next_buf_off == 0) {
    813                     p->next = NULL;
    814                     break;
    815                 } else
    816                     p->next = &p[1];
    817                 p++;
    818             }
    819             break;
    820 
    821         default:
    822             drv_debug_msg(VIDEO_DEBUG_ERROR, "unexpected case\n");
    823 
    824             psb_buffer_unmap(obj_buffer->psb_buffer);
    825             obj_buffer->buffer_data = NULL;
    826             break;
    827         }
    828     }
    829 #endif
    830 
    831     return 0;
    832 }
    833 
    834