secure_device_mem (int fd, guint ctx_id, guint buf_size, gpointer* buffer)
{
int ret = 0;
-// uint32_t opaque = 0;
CodecBufferId opaque;
CODEC_LOG (DEBUG, "enter: %s\n", __func__);
opaque.buffer_size = buf_size;
ret = ioctl (fd, CODEC_CMD_SECURE_BUFFER, &opaque);
+ /* ioctl: CODEC_CMD_SECURE_BUFFER
+ * - sets device memory offset into opaque.buffer_size
+ */
*buffer = (gpointer)((uint32_t)device_mem + opaque.buffer_size);
CODEC_LOG (DEBUG, "buffer: 0x%x\n", (int)buffer);
GST_BUFFER_FREE_FUNC (*buf) = g_free;
- memcpy (info.start, (uint32_t)device_mem + opaque.buffer_size, size);
- release_device_mem(marudec->dev->fd, (uint32_t)device_mem + opaque.buffer_size);
+ memcpy (info.start, device_mem + opaque.buffer_size, size);
+ release_device_mem(marudec->dev->fd, device_mem + opaque.buffer_size);
CODEC_LOG (DEBUG, "we secured last buffer, so we will use heap buffer\n");
} else {
// address of "device_mem" and "opaque" is aleady aligned.
- info.start = (gpointer)((uint32_t)device_mem + opaque.buffer_size);
+ info.start = (gpointer)(device_mem + opaque.buffer_size);
info.offset = opaque.buffer_size;
GST_BUFFER_FREE_FUNC (*buf) = codec_buffer_free;
int
codec_init (CodecContext *ctx, CodecElement *codec, CodecDevice *dev)
{
- int ret = 0, opened = 0, size = 8;
- uint32_t meta_offset = 0;
+ int opened = 0;
+ gpointer buffer = NULL;
+ CodecBufferId opaque;
CODEC_LOG (DEBUG, "enter: %s\n", __func__);
- ret = ioctl(dev->fd, CODEC_CMD_GET_CONTEXT_INDEX, &ctx->index);
- if (ret < 0) {
- GST_ERROR ("failed to get context index\n");
+ if (ioctl(dev->fd, CODEC_CMD_GET_CONTEXT_INDEX, &ctx->index) < 0) {
+ CODEC_LOG (ERR,
+ "[%s] failed to get a context index\n", __func__);
return -1;
}
CODEC_LOG (DEBUG, "get context index: %d\n", ctx->index);
- meta_offset = (ctx->index - 1) * CODEC_META_DATA_SIZE;
- CODEC_LOG (DEBUG,
- "init. ctx: %d meta_offset = 0x%x\n", ctx->index, meta_offset);
+ /* buffer size is 0. It means that this function is required to
+ * use small size.
+ */
+ if (secure_device_mem(dev->fd, ctx->index, 0, &buffer) < 0) {
+ CODEC_LOG (ERR,
+ "[%s] failed to get a memory block\n", __func__);
+ return -1;
+ }
+
+ codec_init_data_to (ctx, codec, buffer);
- _codec_init_meta_to (ctx, codec, device_mem + meta_offset + size);
+ dev->mem_info.offset = GET_OFFSET(buffer);
+ _codec_invoke_qemu (ctx->index, CODEC_INIT, GET_OFFSET(buffer), dev->fd);
- _codec_invoke_qemu (ctx->index, CODEC_INIT, 0, dev->fd);
+ opaque.buffer_index = ctx->index;
+ opaque.buffer_size = SMALLDATA;
- CODEC_LOG (DEBUG,
- "init. ctx: %d meta_offset = 0x%x, size: %d\n", ctx->index, meta_offset, size);
+ if (ioctl (dev->fd, CODEC_CMD_PUT_DATA_INTO_BUFFER, &opaque) < 0) {
+ CODEC_LOG (ERR,
+ "[%s] failed to accquire a memory block\n", __func__);
+ return -1;
+ }
opened =
- _codec_init_meta_from (ctx, codec->media_type, device_mem + meta_offset + size);
- ctx->codec = codec;
+ codec_init_data_from (ctx, codec->media_type, device_mem + opaque.buffer_size);
- CODEC_LOG (DEBUG, "opened: %d\n", opened);
+ if (opened < 0) {
+ CODEC_LOG (ERR, "failed to open Context for %s\n", codec->name);
+ } else {
+ ctx->codec = codec;
+ }
+
+ release_device_mem(dev->fd, device_mem + opaque.buffer_size);
CODEC_LOG (DEBUG, "leave: %s\n", __func__);
gint idx, gint64 in_offset, GstBuffer **out_buf,
int *got_picture_ptr, CodecDevice *dev)
{
- int len = 0, ret = 0, size = 8;
+ int len = 0, ret = 0;
gpointer buffer = NULL;
- uint32_t meta_offset = 0;
+ CodecBufferId opaque;
CODEC_LOG (DEBUG, "enter: %s\n", __func__);
- meta_offset = (ctx->index - 1) * CODEC_META_DATA_SIZE;
- CODEC_LOG (DEBUG, "decode_video. ctx_id: %d meta_offset = 0x%x\n", ctx->index, meta_offset);
- _codec_decode_video_meta_to (in_size, idx, in_offset, device_mem + meta_offset + size);
-
ret = secure_device_mem(dev->fd, ctx->index, in_size, &buffer);
if (ret < 0) {
CODEC_LOG (ERR,
return -1;
}
- _codec_decode_video_inbuf (in_buf, in_size, buffer);
+ codec_decode_video_data_to (in_size, idx, in_offset, in_buf, buffer);
+
dev->mem_info.offset = GET_OFFSET(buffer);
_codec_invoke_qemu (ctx->index, CODEC_DECODE_VIDEO, GET_OFFSET(buffer), dev->fd);
- // after decoding video, no need to get outbuf.
- len =
- _codec_decode_video_meta_from (&ctx->video, got_picture_ptr, device_mem + meta_offset + size);
+ opaque.buffer_index = ctx->index;
+ opaque.buffer_size = SMALLDATA;
+
+ if (ioctl (dev->fd, CODEC_CMD_PUT_DATA_INTO_BUFFER, &opaque) < 0) {
+ CODEC_LOG (ERR,
+ "[%s] failed to accquire a memory block\n", __func__);
+ return -1;
+ }
+
+ len = codec_decode_video_data_from (got_picture_ptr, &ctx->video, device_mem + opaque.buffer_size);
+
+ release_device_mem(dev->fd, device_mem + opaque.buffer_size);
CODEC_LOG (DEBUG, "leave: %s\n", __func__);
int *have_data, uint8_t *in_buf,
int in_size, CodecDevice *dev)
{
- int len = 0, ret = 0, size = 8;
+ int len = 0, ret = 0;
gpointer buffer = NULL;
- uint32_t meta_offset = 0;
CodecBufferId opaque;
CODEC_LOG (DEBUG, "enter: %s\n", __func__);
- meta_offset = (ctx->index - 1) * CODEC_META_DATA_SIZE;
- CODEC_LOG (DEBUG, "decode_audio. ctx_id: %d meta_offset = 0x%x\n", ctx->index, meta_offset);
- _codec_decode_audio_meta_to (in_size, device_mem + meta_offset + size);
-
ret = secure_device_mem(dev->fd, ctx->index, in_size, &buffer);
if (ret < 0) {
CODEC_LOG (ERR,
return -1;
}
- _codec_decode_audio_inbuf (in_buf, in_size, buffer);
+ CODEC_LOG (DEBUG, "decode_audio. in_buffer size %d\n", in_size);
+ codec_decode_audio_data_to (in_size, in_buf, buffer);
+
dev->mem_info.offset = GET_OFFSET(buffer);
_codec_invoke_qemu (ctx->index, CODEC_DECODE_AUDIO, GET_OFFSET(buffer), dev->fd);
if (ret < 0) {
return -1;
}
+
CODEC_LOG (DEBUG, "after decode_audio. ctx_id: %d, buffer = 0x%x\n",
- ctx->index, (int)device_mem + opaque.buffer_size);
+ ctx->index, device_mem + opaque.buffer_size);
len =
- _codec_decode_audio_meta_from (&ctx->audio, have_data, device_mem + meta_offset + size);
- if (len > 0) {
- _codec_decode_audio_outbuf (*have_data, samples, device_mem + opaque.buffer_size);
- } else {
- CODEC_LOG (DEBUG, "decode_audio failure. ctx_id: %d\n", ctx->index);
- }
+ codec_decode_audio_data_from (have_data, samples,
+ &ctx->audio, device_mem + opaque.buffer_size);
+
CODEC_LOG (DEBUG, "decode_audio. ctx_id: %d len: %d\n", ctx->index, len);
release_device_mem(dev->fd, device_mem + opaque.buffer_size);
int out_size, uint8_t *in_buf,
int in_size, int64_t in_timestamp, CodecDevice *dev)
{
- int len = 0, ret = 0, size = 8;
+ int len = 0, ret = 0;
gpointer buffer = NULL;
- uint32_t meta_offset = 0;
CodecBufferId opaque;
CODEC_LOG (DEBUG, "enter: %s\n", __func__);
- meta_offset = (ctx->index - 1) * CODEC_META_DATA_SIZE;
- CODEC_LOG (DEBUG, "encode_video. meta_offset = 0x%x\n", meta_offset);
- _codec_encode_video_meta_to (in_size, in_timestamp, device_mem + meta_offset + size);
-
ret = secure_device_mem(dev->fd, ctx->index, in_size, &buffer);
if (ret < 0) {
CODEC_LOG (ERR, "failed to small size of buffer.\n");
return -1;
}
- _codec_encode_video_inbuf (in_buf, in_size, buffer);
+ codec_encode_video_data_to (in_size, in_timestamp, in_buf, buffer);
+
dev->mem_info.offset = GET_OFFSET(buffer);
_codec_invoke_qemu (ctx->index, CODEC_ENCODE_VIDEO, GET_OFFSET(buffer), dev->fd);
if (ret < 0) {
return -1;
}
- CODEC_LOG (DEBUG, "read, encode_video. mem_offset = 0x%x\n", opaque.buffer_size);
-
- memcpy (&len, device_mem + meta_offset + size, sizeof(len));
+ CODEC_LOG (DEBUG, "encode_video. mem_offset = 0x%x\n", opaque.buffer_size);
- CODEC_LOG (DEBUG, "encode_video. outbuf size: %d\n", len);
- if (len > 0) {
- memcpy (out_buf, device_mem + opaque.buffer_size, len);
- dev->mem_info.offset = opaque.buffer_size;
- }
+ len = codec_encode_video_data_from (out_buf, device_mem + opaque.buffer_size);
+ dev->mem_info.offset = opaque.buffer_size;
release_device_mem(dev->fd, device_mem + opaque.buffer_size);
int max_size, uint8_t *in_buf,
int in_size, CodecDevice *dev)
{
- int len = 0, ret = 0, size = 8;
+ int len = 0, ret = 0;
gpointer buffer = NULL;
- uint32_t meta_offset = 0;
CodecBufferId opaque;
CODEC_LOG (DEBUG, "enter: %s\n", __func__);
- meta_offset = (ctx->index - 1) * CODEC_META_DATA_SIZE;
- CODEC_LOG (DEBUG, "encode_audio. meta mem_offset = 0x%x\n", meta_offset);
- _codec_encode_audio_meta_to (max_size, in_size, device_mem + meta_offset + size);
-
ret = secure_device_mem(dev->fd, ctx->index, in_size, &buffer);
if (ret < 0) {
return -1;
}
- _codec_encode_audio_inbuf (in_buf, in_size, buffer);
+ codec_encode_audio_data_to (in_size, max_size, in_buf, buffer);
+
dev->mem_info.offset = GET_OFFSET(buffer);
_codec_invoke_qemu (ctx->index, CODEC_ENCODE_AUDIO, GET_OFFSET(buffer), dev->fd);
return -1;
}
- CODEC_LOG (DEBUG, "read, encode_video. mem_offset = 0x%x\n", opaque.buffer_size);
+ CODEC_LOG (DEBUG, "encode_video. mem_offset = 0x%x\n", opaque.buffer_size);
- len = _codec_encode_audio_outbuf (out_buf, device_mem + opaque.buffer_size);
+ len = codec_encode_audio_data_from (out_buf, device_mem + opaque.buffer_size);
release_device_mem(dev->fd, device_mem + opaque.buffer_size);
/*
* GStreamer codec plugin for Tizen Emulator.
*
- * Copyright (C) 2013 Samsung Electronics Co., Ltd. All rights reserved.
+ * Copyright (C) 2013 - 2014 Samsung Electronics Co., Ltd. All rights reserved.
*
* Contact:
* KiTae Kim <kt920.kim@samsung.com>
* codec data such as codec name, longname, media type and etc.
*/
static int
-_codec_info_data (CodecElement *codec, uint8_t *device_buf)
+_codec_info_data (CodecElement *codec, gpointer buffer)
{
- int size = 0;
+ int size = sizeof(size);
CODEC_LOG (DEBUG, "enter, %s\n", __func__);
CODEC_LOG (DEBUG, "type: %d, name: %s\n", codec->codec_type, codec->name);
- memcpy (device_buf, &codec->codec_type, sizeof(codec->codec_type));
- size = sizeof(codec->codec_type);
+ memcpy (buffer + size, &codec->codec_type, sizeof(codec->codec_type));
+ size += sizeof(codec->codec_type);
- memcpy (device_buf + size, codec->name, sizeof(codec->name));
+ memcpy (buffer + size, codec->name, sizeof(codec->name));
size += sizeof(codec->name);
CODEC_LOG (DEBUG, "leave, %s\n", __func__);
}
void
-_codec_init_meta_to (CodecContext *ctx,
- CodecElement *codec,
- uint8_t *device_buf)
+codec_init_data_to (CodecContext *ctx, CodecElement *codec, gpointer buffer)
{
int size = 0;
CODEC_LOG (DEBUG, "enter, %s\n", __func__);
- size = _codec_info_data (codec, device_buf);
+ size = _codec_info_data (codec, buffer);
CODEC_LOG (INFO, "context_id: %d, name: %s, media type: %s\n",
ctx->index, codec->name, codec->media_type ? "AUDIO" : "VIDEO");
- CODEC_LOG (DEBUG, "init. write data to qemu, size: %d\n", size);
- memcpy (device_buf + size, ctx, sizeof(CodecContext) - 12);
+ memcpy (buffer + size, ctx, sizeof(CodecContext) - 12);
size += (sizeof(CodecContext) - 12);
- memcpy (device_buf + size, ctx->codecdata, ctx->codecdata_size);
+ memcpy (buffer + size, ctx->codecdata, ctx->codecdata_size);
+ size += ctx->codecdata_size;
+
+ // data length
+ size -= sizeof(size);
+ memcpy (buffer, &size, sizeof(size));
CODEC_LOG (DEBUG, "leave, %s\n", __func__);
}
int
-_codec_init_meta_from (CodecContext *ctx,
- int media_type,
- uint8_t *device_buf)
+codec_init_data_from (CodecContext *ctx, int media_type, gpointer buffer)
{
int ret = 0, size = 0;
CODEC_LOG (DEBUG, "after init. read data from device.\n");
- memcpy (&ret, device_buf, sizeof(ret));
+ memcpy (&ret, buffer, sizeof(ret));
size = sizeof(ret);
- if (!ret) {
+ if (ret < 0) {
+ return ret;
+ } else {
if (media_type == AVMEDIA_TYPE_AUDIO) {
- AudioData audio = { 0 };
+ memcpy (&ctx->audio.sample_fmt, buffer + size, sizeof(ctx->audio.sample_fmt));
+ size += sizeof(ctx->audio.sample_fmt);
+
+ memcpy (&ctx->audio.frame_size, buffer + size, sizeof(ctx->audio.frame_size));
+ size += sizeof(ctx->audio.frame_size);
+ memcpy(&ctx->audio.bits_per_sample_fmt, buffer + size, sizeof(ctx->audio.bits_per_sample_fmt));
#if 0
- memcpy(&audio, device_buf + size, sizeof(AudioData));
- ctx->audio.sample_fmt = audio.sample_fmt;
- ctx->audio.frame_size = audio.frame_size;
- ctx->audio.bits_per_sample_fmt = audio.bits_per_sample_fmt;
+ // TODO: check!!
+ memcpy (&ctx->audio, buffer + size, sizeof(ctx->audio));
#endif
- CODEC_LOG (DEBUG,
- "audio sample_fmt: %d\n", *(int *)(device_buf + size));
-
- memcpy(&ctx->audio.sample_fmt, device_buf + size, sizeof(audio.sample_fmt));
- size += sizeof(audio.sample_fmt);
- memcpy(&ctx->audio.frame_size, device_buf + size, sizeof(audio.frame_size));
- size += sizeof(audio.frame_size);
- memcpy(&ctx->audio.bits_per_sample_fmt, device_buf + size, sizeof(audio.bits_per_sample_fmt));
-
- CODEC_LOG (DEBUG,
- "after init. audio sample_fmt: %d\n", ctx->audio.sample_fmt);
+ } else {
+ CODEC_LOG (DEBUG, "video type\n");
}
- } else {
- CODEC_LOG (ERR, "failed to open codec context\n");
}
return ret;
}
void
-_codec_decode_video_meta_to (int in_size, int idx, int64_t in_offset, uint8_t *device_buf)
-{
- memcpy (device_buf, &in_size, sizeof(in_size));
- memcpy (device_buf + sizeof(in_size), &idx, sizeof(idx));
- memcpy (device_buf + sizeof(idx), &in_offset, sizeof(in_offset));
-}
-
-void
-_codec_decode_video_inbuf (uint8_t *in_buf, int in_size, uint8_t *device_buf)
+codec_decode_video_data_to (int in_size, int idx, int64_t in_offset,
+ uint8_t *in_buf, gpointer buffer)
{
int size = 0;
- memcpy(device_buf, &in_size, sizeof(in_size));
- size = sizeof(in_size);
- if (in_size > 0 ) {
- memcpy (device_buf + size, in_buf, in_size);
+ size = sizeof(size);
+ memcpy (buffer + size, &in_size, sizeof(in_size));
+ size += sizeof(in_size);
+ memcpy (buffer + size, &idx, sizeof(idx));
+ size += sizeof(idx);
+ memcpy (buffer + size, &in_offset, sizeof(in_offset));
+ size += sizeof(in_offset);
+
+ if (in_size > 0) {
+ memcpy (buffer + size, in_buf, in_size);
+ size += in_size;
}
CODEC_LOG (DEBUG, "decode_video. inbuf_size: %d\n", in_size);
+
+ size -= sizeof(size);
+ memcpy (buffer, &size, sizeof(size));
}
int
-_codec_decode_video_meta_from (VideoData *video,
- int *got_picture_ptr,
- uint8_t *device_buf)
+codec_decode_video_data_from (int *got_picture_ptr, VideoData *video, gpointer buffer)
{
- int len = 0, size = 0;
+ int size = 0, len = 0;
- CODEC_LOG (DEBUG, "decode_video. read data from qemu.\n");
-
- memcpy (&len, device_buf, sizeof(len));
+ memcpy (&len, buffer, sizeof(len));
size = sizeof(len);
- memcpy (got_picture_ptr,
- device_buf + size, sizeof(*got_picture_ptr));
+ memcpy (got_picture_ptr, buffer + size, sizeof(*got_picture_ptr));
size += sizeof(*got_picture_ptr);
- memcpy (video, device_buf + size, sizeof(VideoData));
+ memcpy (video, buffer + size, sizeof(VideoData));
- CODEC_LOG (DEBUG, "decode_video. len: %d, have_data: %d\n",
- len, *got_picture_ptr);
+ CODEC_LOG (DEBUG, "decode_video. len: %d, have_data: %d\n", len, *got_picture_ptr);
return len;
}
void
-_codec_decode_audio_meta_to (int in_size, uint8_t *device_buf)
-{
- memcpy (device_buf, &in_size, sizeof(in_size));
-}
-
-
-void
-_codec_decode_audio_inbuf (uint8_t *in_buf, int in_size, uint8_t *device_buf)
+codec_decode_audio_data_to (int in_size, uint8_t *in_buf, gpointer buffer)
{
int size = 0;
- memcpy (device_buf, &in_size, sizeof(in_size));
- size = sizeof(in_size);
+ size = sizeof(size);
+ memcpy (buffer + size, &in_size, sizeof(in_size));
+ size += sizeof(in_size);
if (in_size > 0) {
- memcpy (device_buf + size, in_buf, in_size);
+ memcpy (buffer + size, in_buf, in_size);
+ size += in_size;
}
- CODEC_LOG (DEBUG, "decode_audio. inbuf_size: %d\n", in_size);
+ size -= sizeof(size);
+ memcpy (buffer, &size, sizeof(size));
}
int
-_codec_decode_audio_meta_from (AudioData *audio, int *frame_size_ptr,
- uint8_t *device_buf)
+codec_decode_audio_data_from (int *have_data, int16_t *samples,
+ AudioData *audio, gpointer buffer)
{
int len = 0, size = 0;
- CODEC_LOG (DEBUG, "decode_audio. read data from device.\n");
+ memcpy (&len, buffer, sizeof(len));
+ size = sizeof(len);
+ memcpy (have_data, buffer + size, sizeof(*have_data));
+ size += sizeof(*have_data);
- memcpy (&audio->sample_rate,
- device_buf, sizeof(audio->sample_rate));
- size = sizeof(audio->sample_rate);
- memcpy (&audio->channels,
- device_buf + size, sizeof(audio->channels));
- size += sizeof(audio->channels);
- memcpy (&audio->channel_layout,
- device_buf + size, sizeof(audio->channel_layout));
- size += sizeof(audio->channel_layout);
- memcpy (&len, device_buf + size, sizeof(len));
- size += sizeof(len);
- memcpy (frame_size_ptr, device_buf + size, sizeof(*frame_size_ptr));
+ CODEC_LOG (DEBUG, "decode_audio. len %d, have_data %d\n",
+ len, (*have_data));
- CODEC_LOG (DEBUG, "decode_audio. len: %d, frame_size: %d\n",
- len, (*frame_size_ptr));
+ if (*have_data) {
+ memcpy (&audio->sample_rate, buffer + size, sizeof(audio->sample_rate));
+ size += sizeof(audio->sample_rate);
- return len;
-}
+ memcpy (&audio->channels, buffer + size, sizeof(audio->channels));
+ size += sizeof(audio->channels);
-void
-_codec_decode_audio_outbuf (int outbuf_size, int16_t *samples, uint8_t *device_buf)
-{
- CODEC_LOG (DEBUG, "decode_audio. read outbuf %d\n", outbuf_size);
- memcpy (samples, device_buf, outbuf_size);
-}
+ memcpy (&audio->channel_layout, buffer + size, sizeof(audio->channel_layout));
+ size += sizeof(audio->channel_layout);
-void
-_codec_encode_video_meta_to (int in_size, int64_t in_timestamp, uint8_t *device_buf)
-{
- CODEC_LOG (DEBUG, "encode_video. write data to device.\n");
+ CODEC_LOG (DEBUG, "decode_audio. sample_rate %d, channels %d, ch_layout %lld\n", audio->sample_rate, audio->channels, audio->channel_layout);
- memcpy (device_buf, &in_size, sizeof(in_size));
- memcpy (device_buf + sizeof(in_size), &in_timestamp, sizeof(in_timestamp));
+ memcpy (samples, buffer + size, (*have_data));
+ }
+
+ return len;
}
void
-_codec_encode_video_inbuf (uint8_t *in_buf, int in_size, uint8_t *device_buf)
+codec_encode_video_data_to (int in_size, int64_t in_timestamp,
+ uint8_t *in_buf, gpointer buffer)
{
int size = 0;
- memcpy ((uint8_t *)device_buf, &in_size, sizeof(in_size));
+ size = sizeof(size);
+ memcpy (buffer + size, &in_size, sizeof(in_size));
size += sizeof(in_size);
+ memcpy (buffer + size, &in_timestamp, sizeof(in_timestamp));
+ size += sizeof(in_timestamp);
if (in_size > 0) {
- memcpy (device_buf + size, in_buf, in_size);
+ memcpy (buffer + size, in_buf, in_size);
+ size += in_size;
}
- CODEC_LOG (DEBUG, "encode_video. inbuf_size: %d\n", in_size);
+
+ size -= sizeof(size);
+ memcpy (buffer, &size, sizeof(size));
}
-void
-_codec_encode_video_outbuf (int len, uint8_t *out_buf, uint8_t *device_buf)
+int
+codec_encode_video_data_from (uint8_t *out_buf, gpointer buffer)
{
-// int len, size;
+ int len = 0, size = 0;
- CODEC_LOG (DEBUG, "encode_video. read data from device.\n");
+ memcpy (&len, buffer, sizeof(len));
+ size = sizeof(len);
-// memcpy (&len, device_buf, sizeof(len));
-// size = sizeof(len);
- memcpy (out_buf, device_buf, len);
+ CODEC_LOG (DEBUG, "encode_video. outbuf size: %d\n", len);
+ if (len > 0) {
+ memcpy (out_buf, buffer + size, len);
+ // dev->mem_info.offset = opaque.buffer_size;
+ }
-// return len;
+ return len;
}
void
-_codec_encode_audio_meta_to (int max_size, int in_size, uint8_t *device_buf)
+codec_encode_audio_data_to (int in_size, int max_size, uint8_t *in_buf, gpointer buffer)
{
int size = 0;
- CODEC_LOG (DEBUG, "encode_audio. write data to device.\n");
-
- memcpy (device_buf, &in_size, sizeof(in_size));
- size = sizeof(in_size);
- memcpy (device_buf + size, &max_size, sizeof(max_size));
-}
-
-void
-_codec_encode_audio_inbuf (uint8_t *in_buf, int in_size, uint8_t *device_buf)
-{
- int size = 0;
+ size = sizeof(size);
+ memcpy (buffer + size, &in_size, sizeof(in_size));
+ size += sizeof(in_size);
+ memcpy (buffer + size, &max_size, sizeof(max_size));
+ size += sizeof(max_size);
- memcpy (device_buf, &in_size, sizeof(in_size));
- size = sizeof(in_size);
if (in_size > 0) {
- memcpy (device_buf + size, in_buf, in_size);
+ memcpy (buffer + size, in_buf, in_size);
+ size += in_size;
}
- CODEC_LOG (DEBUG, "encode_audio. inbuf_size: %d\n", in_size);
+
+ size -= sizeof(size);
+ memcpy (buffer, &size, sizeof(size));
}
int
-_codec_encode_audio_outbuf (uint8_t *out_buf, uint8_t *device_buf)
+codec_encode_audio_data_from (uint8_t *out_buf, gpointer buffer)
{
- int len, size;
-
- CODEC_LOG (DEBUG, "encode_audio. read data from device\n");
+ int len = 0, size = 0;
- memcpy (&len, (uint8_t *)device_buf, sizeof(len));
+ memcpy (&len, buffer, sizeof(len));
size = sizeof(len);
- memcpy (out_buf, (uint8_t *)device_buf + size, len);
+ if (len > 0) {
+ memcpy (out_buf, buffer + size, len);
+ }
+
+ CODEC_LOG (DEBUG, "encode_audio. outbuf size: %d\n", len);
return len;
}
projects / platform / adaptation / emulator / gst-plugins-emulator.git / commitdiff