src/gstmaruinterface.c

   1 /*
   2  * GStreamer codec plugin for Tizen Emulator.
   3  *
   4  * Copyright (C) 2013 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact:
   7  * KiTae Kim <kt920.kim@samsung.com>
   8  * SeokYeon Hwang <syeon.hwang@samsung.com>
   9  * YeongKyoon Lee <yeongkyoon.lee@samsung.com>
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Library General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Library General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Library General Public
  22  * License along with this library; if not, write to the
  23  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  24  * Boston, MA 02111-1307, USA.
  25  *
  26  * Contributors:
  27  * - S-Core Co., Ltd
  28  *
  29  */
  30
  31 #include "gstmaru.h"
  32 #include "gstmaruinterface.h"
  33 #include "gstmaruutils.h"
  34 #include "gstmarumem.h"
  35 #include "gstmarudevice.h"
  36
  37 extern int device_fd;
  38 extern gpointer device_mem;
  39
  40 typedef struct _CodecHeader {
  41   int32_t   api_index;
  42   uint32_t  mem_offset;
  43 } CodecHeader;
  44
  45 typedef struct _CodecBufferId {
  46   uint32_t  buffer_index;
  47   uint32_t  buffer_size;
  48 } CodecBufferId;
  49
  50 typedef struct _CodecIOParams {
  51   int32_t   api_index;
  52   int32_t   ctx_index;
  53   uint32_t  mem_offset;
  54
  55   CodecBufferId buffer_id;
  56 } CodecIOParams;
  57
  58
  59 #define CODEC_META_DATA_SIZE    256
  60 #define GET_OFFSET(buffer)      ((uint32_t)buffer - (uint32_t)device_mem)
  61 #define SMALLDATA               0
  62
  63 #define OFFSET_PICTURE_BUFFER   0x100
  64
  65 static int
  66 _codec_invoke_qemu(int32_t ctx_index, int32_t api_index,
  67                           uint32_t mem_offset, int fd, CodecBufferId *buffer_id)
  68 {
  69   CodecIOParams ioparam = { 0, };
  70   int ret = -1;
  71
  72   CODEC_LOG (DEBUG, "enter: %s\n", __func__);
  73
  74   ioparam.api_index = api_index;
  75   ioparam.ctx_index = ctx_index;
  76   ioparam.mem_offset = mem_offset;
  77
  78   if (CHECK_VERSION(3)) {
  79     if (buffer_id) {
  80       ioparam.buffer_id.buffer_index = buffer_id->buffer_index;
  81       ioparam.buffer_id.buffer_size = buffer_id->buffer_size;
  82     }
  83
  84     ret = ioctl(fd, CODEC_CMD_INVOKE_API_AND_RELEASE_BUFFER, &ioparam);
  85
  86     if (buffer_id) {
  87       buffer_id->buffer_index = ioparam.buffer_id.buffer_index;
  88       buffer_id->buffer_size = ioparam.buffer_id.buffer_size;
  89     }
  90   } else {
  91     if (ioctl(fd, CODEC_CMD_INVOKE_API_AND_RELEASE_BUFFER, &ioparam) < 0) {
  92       return -1;
  93     }
  94     if (buffer_id) {
  95       ret = ioctl(fd, CODEC_CMD_PUT_DATA_INTO_BUFFER, buffer_id);
  96     }
  97   }
  98
  99   CODEC_LOG (DEBUG, "leave: %s\n", __func__);
 100
 101   return ret;
 102 }
 103
 104 static int
 105 secure_device_mem (int fd, guint ctx_id, guint buf_size, gpointer* buffer)
 106 {
 107   int ret = 0;
 108   CodecBufferId opaque;
 109
 110   CODEC_LOG (DEBUG, "enter: %s\n", __func__);
 111   opaque.buffer_index = ctx_id;
 112   opaque.buffer_size = buf_size;
 113
 114   ret = ioctl (fd, CODEC_CMD_SECURE_BUFFER, &opaque);
 115   /* ioctl: CODEC_CMD_SECURE_BUFFER
 116    *  - sets device memory offset into opaque.buffer_size
 117    */
 118   *buffer = (gpointer)((uint32_t)device_mem + opaque.buffer_size);
 119   GST_DEBUG ("device_mem %p, offset_size 0x%x", device_mem, opaque.buffer_size);
 120
 121   CODEC_LOG (DEBUG, "leave: %s\n", __func__);
 122
 123   return ret;
 124 }
 125
 126 static void
 127 release_device_mem (int fd, gpointer start)
 128 {
 129   int ret;
 130   uint32_t offset = start - device_mem;
 131
 132   CODEC_LOG (DEBUG, "enter: %s\n", __func__);
 133
 134   GST_DEBUG ("release device_mem start: %p, offset: 0x%x", start, offset);
 135   ret = ioctl (fd, CODEC_CMD_RELEASE_BUFFER, &offset);
 136   if (ret < 0) {
 137     GST_ERROR ("failed to release buffer\n");
 138   }
 139
 140   CODEC_LOG (DEBUG, "leave: %s\n", __func__);
 141 }
 142
 143 static void
 144 codec_buffer_free (gpointer start)
 145 {
 146   CODEC_LOG (DEBUG, "enter: %s\n", __func__);
 147
 148   if (use_new_decode_api()) {
 149     release_device_mem (device_fd, start - OFFSET_PICTURE_BUFFER); // FIXME
 150   } else {
 151     release_device_mem (device_fd, start);
 152   }
 153
 154   CODEC_LOG (DEBUG, "leave: %s\n", __func__);
 155 }
 156
 157 GstFlowReturn
 158 codec_buffer_alloc_and_copy (GstPad *pad, guint64 offset, guint size,
 159                   GstCaps *caps, GstBuffer **buf)
 160 {
 161   bool is_last_buffer = 0;
 162   int mem_offset;
 163   CodecBufferId opaque;
 164   GstMaruDec *marudec;
 165   CodecContext *ctx;
 166   CodecDevice *dev;
 167
 168   CODEC_LOG (DEBUG, "enter: %s\n", __func__);
 169
 170   *buf = gst_buffer_new ();
 171
 172   marudec = (GstMaruDec *)gst_pad_get_element_private(pad);
 173   ctx = marudec->context;
 174   dev = marudec->dev;
 175
 176   if (use_new_decode_api()) {
 177     is_last_buffer = marudec->is_last_buffer;
 178     mem_offset = marudec->mem_offset;
 179   } else {
 180     ctx = marudec->context;
 181
 182     opaque.buffer_index = ctx->index;
 183     opaque.buffer_size = size;
 184
 185     GST_DEBUG ("buffer_and_copy. ctx_id: %d", ctx->index);
 186
 187     int ret = _codec_invoke_qemu(ctx->index, CODEC_PICTURE_COPY, 0, dev->fd, &opaque);
 188     if (ret < 0) {
 189       GST_DEBUG ("failed to get available buffer");
 190       return GST_FLOW_ERROR;
 191     }
 192     is_last_buffer = ret;
 193     mem_offset = opaque.buffer_size;
 194   }
 195
 196   gpointer *buffer = NULL;
 197   if (is_last_buffer) {
 198     // FIXME: we must aligned buffer offset.
 199     buffer = g_malloc (size);
 200
 201     GST_BUFFER_FREE_FUNC (*buf) = g_free;
 202
 203     if (use_new_decode_api()) {
 204       memcpy (buffer, device_mem + mem_offset + OFFSET_PICTURE_BUFFER, size);
 205     } else {
 206       memcpy (buffer, device_mem + mem_offset, size);
 207     }
 208     release_device_mem(dev->fd, device_mem + mem_offset);
 209
 210     GST_DEBUG ("secured last buffer!! Use heap buffer");
 211   } else {
 212     // address of "device_mem" and "opaque" is aleady aligned.
 213     if (use_new_decode_api()) {
 214       buffer = (gpointer)(device_mem + mem_offset + OFFSET_PICTURE_BUFFER);
 215     } else {
 216       buffer = (gpointer)(device_mem + mem_offset);
 217     }
 218
 219     GST_BUFFER_FREE_FUNC (*buf) = codec_buffer_free;
 220
 221     GST_DEBUG ("device memory start: 0x%p, offset 0x%x", (intptr_t)buffer, mem_offset);
 222   }
 223
 224   GST_BUFFER_DATA (*buf) = GST_BUFFER_MALLOCDATA (*buf) = buffer;
 225   GST_BUFFER_SIZE (*buf) = size;
 226   GST_BUFFER_OFFSET (*buf) = offset;
 227
 228   if (caps) {
 229     gst_buffer_set_caps (*buf, caps);
 230   }
 231
 232   CODEC_LOG (DEBUG, "leave: %s\n", __func__);
 233
 234   return GST_FLOW_OK;
 235 }
 236
 237 int
 238 codec_init (CodecContext *ctx, CodecElement *codec, CodecDevice *dev)
 239 {
 240   int opened = 0;
 241   gpointer buffer = NULL;
 242   CodecBufferId opaque;
 243   int ret;
 244
 245   CODEC_LOG (DEBUG, "enter: %s\n", __func__);
 246
 247   if (ioctl(dev->fd, CODEC_CMD_GET_CONTEXT_INDEX, &ctx->index) < 0) {
 248     GST_ERROR ("failed to get a context index");
 249     return -1;
 250   }
 251   GST_DEBUG ("get context index: %d", ctx->index);
 252
 253   /* buffer size is 0. It means that this function is required to
 254    * use small size.
 255   */
 256   if (secure_device_mem(dev->fd, ctx->index, 0, &buffer) < 0) {
 257     GST_ERROR ("failed to get a memory block");
 258     return -1;
 259   }
 260
 261   codec_init_data_to (ctx, codec, buffer);
 262
 263   opaque.buffer_index = ctx->index;
 264   opaque.buffer_size = SMALLDATA;
 265
 266   ret = _codec_invoke_qemu (ctx->index, CODEC_INIT, GET_OFFSET(buffer), dev->fd, &opaque);
 267
 268   if (ret < 0) {
 269     return -1;
 270   }
 271
 272   opened =
 273     codec_init_data_from (ctx, codec->media_type, device_mem + opaque.buffer_size);
 274
 275   if (opened < 0) {
 276     GST_ERROR ("failed to open Context for %s", codec->name);
 277   } else {
 278     ctx->codec = codec;
 279   }
 280
 281   release_device_mem(dev->fd, device_mem + opaque.buffer_size);
 282
 283   CODEC_LOG (DEBUG, "leave: %s\n", __func__);
 284
 285   return opened;
 286 }
 287
 288 void
 289 codec_deinit (CodecContext *ctx, CodecDevice *dev)
 290 {
 291   CODEC_LOG (DEBUG, "enter: %s\n", __func__);
 292
 293   GST_INFO ("close context %d", ctx->index);
 294   _codec_invoke_qemu (ctx->index, CODEC_DEINIT, 0, dev->fd, NULL);
 295
 296   CODEC_LOG (DEBUG, "leave: %s\n", __func__);
 297 }
 298
 299 void
 300 codec_flush_buffers (CodecContext *ctx, CodecDevice *dev)
 301 {
 302   CODEC_LOG (DEBUG, "enter: %s\n", __func__);
 303
 304   GST_DEBUG ("flush buffers of context: %d", ctx->index);
 305   _codec_invoke_qemu (ctx->index, CODEC_FLUSH_BUFFERS, 0, dev->fd, NULL);
 306
 307   CODEC_LOG (DEBUG, "leave: %s\n", __func__);
 308 }
 309
 310 int
 311 codec_decode_video (GstMaruDec *marudec, uint8_t *in_buf, int in_size,
 312                     gint idx, gint64 in_offset, GstBuffer **out_buf, int *have_data)
 313 {
 314   CodecContext *ctx = marudec->context;
 315   CodecDevice *dev = marudec->dev;
 316   int len = 0, ret = 0;
 317   gpointer buffer = NULL;
 318   CodecBufferId opaque = { 0, };
 319
 320   CODEC_LOG (DEBUG, "enter: %s\n", __func__);
 321
 322   ret = secure_device_mem(dev->fd, ctx->index, in_size, &buffer);
 323   if (ret < 0) {
 324     GST_ERROR ("failed to get available memory to write inbuf");
 325     return -1;
 326   }
 327
 328   codec_decode_video_data_to (in_size, idx, in_offset, in_buf, buffer);
 329
 330   opaque.buffer_index = ctx->index;
 331   if (use_new_decode_api()) {
 332     int picture_size = gst_maru_avpicture_size (ctx->video.pix_fmt,
 333         ctx->video.width, ctx->video.height);
 334     if (picture_size < 0) {
 335       opaque.buffer_size = SMALLDATA;
 336     } else {
 337       opaque.buffer_size = picture_size;
 338     }
 339     ret = _codec_invoke_qemu(ctx->index, CODEC_DECODE_VIDEO2, GET_OFFSET(buffer), dev->fd, &opaque);
 340   } else {
 341     opaque.buffer_size = SMALLDATA;
 342     ret = _codec_invoke_qemu(ctx->index, CODEC_DECODE_VIDEO, GET_OFFSET(buffer), dev->fd, &opaque);
 343   }
 344
 345   if (ret < 0) {
 346     // FIXME:
 347     return -1;
 348   }
 349   len = codec_decode_video_data_from (have_data, &ctx->video, device_mem + opaque.buffer_size);
 350
 351   GST_DEBUG_OBJECT (marudec, "after decode: len %d, have_data %d",
 352         len, *have_data);
 353   if (len < 0 || *have_data <= 0) {
 354     GST_DEBUG_OBJECT (marudec, "return flow %d, out %p, len %d",
 355         ret, *out_buf, len);
 356
 357     release_device_mem(dev->fd, device_mem + opaque.buffer_size);
 358
 359     return len;
 360   }
 361
 362   if (use_new_decode_api()) {
 363     marudec->is_last_buffer = ret;
 364     marudec->mem_offset = opaque.buffer_size;
 365   } else {
 366     release_device_mem(dev->fd, device_mem + opaque.buffer_size);
 367   }
 368
 369   CODEC_LOG (DEBUG, "leave: %s\n", __func__);
 370
 371   return len;
 372 }
 373
 374 int
 375 codec_decode_audio (CodecContext *ctx, int16_t *samples,
 376                     int *have_data, uint8_t *in_buf,
 377                     int in_size, CodecDevice *dev)
 378 {
 379   int len = 0, ret = 0;
 380   gpointer buffer = NULL;
 381   CodecBufferId opaque;
 382
 383   CODEC_LOG (DEBUG, "enter: %s\n", __func__);
 384
 385   ret = secure_device_mem(dev->fd, ctx->index, in_size, &buffer);
 386   if (ret < 0) {
 387     GST_ERROR ("failed to get available memory to write inbuf");
 388     return -1;
 389   }
 390
 391   GST_DEBUG ("decode_audio 1. in_buffer size %d", in_size);
 392   codec_decode_audio_data_to (in_size, in_buf, buffer);
 393
 394   opaque.buffer_index = ctx->index;
 395   opaque.buffer_size = SMALLDATA;
 396
 397   ret = _codec_invoke_qemu(ctx->index, CODEC_DECODE_AUDIO, GET_OFFSET(buffer), dev->fd, &opaque);
 398
 399   if (ret < 0) {
 400     return -1;
 401   }
 402
 403   GST_DEBUG ("decode_audio 2. ctx_id: %d, buffer = 0x%x",
 404     ctx->index, device_mem + opaque.buffer_size);
 405
 406   len = codec_decode_audio_data_from (have_data, samples,
 407     &ctx->audio, device_mem + opaque.buffer_size);
 408
 409   GST_DEBUG ("decode_audio 3. ctx_id: %d len: %d", ctx->index, len);
 410
 411   release_device_mem(dev->fd, device_mem + opaque.buffer_size);
 412
 413   CODEC_LOG (DEBUG, "leave: %s\n", __func__);
 414
 415   return len;
 416 }
 417
 418 int
 419 codec_encode_video (CodecContext *ctx, uint8_t *out_buf,
 420                     int out_size, uint8_t *in_buf,
 421                     int in_size, int64_t in_timestamp,
 422                     int *coded_frame, int *is_keyframe,
 423                     CodecDevice *dev)
 424 {
 425   int len = 0, ret = 0;
 426   gpointer buffer = NULL;
 427   CodecBufferId opaque;
 428
 429   CODEC_LOG (DEBUG, "enter: %s\n", __func__);
 430
 431   ret = secure_device_mem(dev->fd, ctx->index, in_size, &buffer);
 432   if (ret < 0) {
 433     GST_ERROR ("failed to small size of buffer");
 434     return -1;
 435   }
 436
 437   codec_encode_video_data_to (in_size, in_timestamp, in_buf, buffer);
 438
 439   opaque.buffer_index = ctx->index;
 440   opaque.buffer_size = SMALLDATA;
 441
 442   // FIXME: how can we know output data size ?
 443   ret = _codec_invoke_qemu(ctx->index, CODEC_ENCODE_VIDEO, GET_OFFSET(buffer), dev->fd, &opaque);
 444
 445   if (ret < 0) {
 446     return -1;
 447   }
 448
 449   GST_DEBUG ("encode_video. mem_offset = 0x%x", opaque.buffer_size);
 450
 451   len = codec_encode_video_data_from (out_buf, coded_frame, is_keyframe, device_mem + opaque.buffer_size);
 452
 453   release_device_mem(dev->fd, device_mem + opaque.buffer_size);
 454
 455   CODEC_LOG (DEBUG, "leave: %s\n", __func__);
 456
 457   return len;
 458 }
 459
 460 int
 461 codec_encode_audio (CodecContext *ctx, uint8_t *out_buf,
 462                     int max_size, uint8_t *in_buf,
 463                     int in_size, int64_t timestamp,
 464                     CodecDevice *dev)
 465 {
 466   int ret = 0;
 467   gpointer buffer = NULL;
 468   CodecBufferId opaque;
 469
 470   CODEC_LOG (DEBUG, "enter: %s\n", __func__);
 471
 472   ret = secure_device_mem(dev->fd, ctx->index, in_size, &buffer);
 473   if (ret < 0) {
 474     return -1;
 475   }
 476
 477   codec_encode_audio_data_to (in_size, max_size, in_buf, timestamp, buffer);
 478
 479   opaque.buffer_index = ctx->index;
 480   opaque.buffer_size = SMALLDATA;
 481
 482   ret = _codec_invoke_qemu(ctx->index, CODEC_ENCODE_AUDIO, GET_OFFSET(buffer), dev->fd, &opaque);
 483
 484   if (ret < 0) {
 485     return -1;
 486   }
 487
 488   GST_DEBUG ("encode_audio. mem_offset = 0x%x", opaque.buffer_size);
 489
 490   ret = codec_encode_audio_data_from (out_buf, device_mem + opaque.buffer_size);
 491
 492   release_device_mem(dev->fd, device_mem + opaque.buffer_size);
 493
 494   CODEC_LOG (DEBUG, "leave: %s\n", __func__);
 495
 496   return ret;
 497 }