From: Kitae Kim Date: Thu, 7 Aug 2014 07:58:50 +0000 (+0900) Subject: codec: remove unused module X-Git-Tag: Tizen_Studio_1.3_Release_p2.3.1~228^2^2~35^2 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=8fb9bed76e36e669852dea59dd8da68c8be16638;p=sdk%2Femulator%2Fqemu.git codec: remove unused module codec device has been replaced into brillcodec. In addition to this, its source does not need to maintain any more. Change-Id: I6451ab43eb6c84b75a45dfbf17183f8e19812b51 Signed-off-by: Kitae Kim --- diff --git a/tizen/src/hw/pci/maru_codec.c b/tizen/src/hw/pci/maru_codec.c deleted file mode 100644 index 2c9b2db52a..0000000000 --- a/tizen/src/hw/pci/maru_codec.c +++ /dev/null @@ -1,1690 +0,0 @@ -/* - * Virtual Codec device - * - * Copyright (c) 2011 - 2013 Samsung Electronics Co., Ltd All Rights Reserved - * - * Contact: - * Kitae Kim - * SeokYeon Hwang - * YeongKyoon Lee - * DongKyun Yun - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, - * MA 02110-1301, USA. - * - * Contributors: - * - S-Core Co., Ltd - * - */ - -#include "maru_codec.h" -#include "qemu-common.h" - -#define MARU_CODEC_DEV_NAME "codec" -#define MARU_CODEC_VERSION 14 - -/* Needs 16M to support 1920x1080 video resolution. - * Output size for encoding has to be greater than (width * height * 6) - */ -#define MARU_CODEC_MEM_SIZE (2 * 16 * 1024 * 1024) -#define MARU_CODEC_REG_SIZE (256) -#define MARU_CODEC_IRQ 0x7f - -#define GEN_MASK(x) ((1<<(x))-1) -#define ROUND_UP_X(v, x) (((v) + GEN_MASK(x)) & ~GEN_MASK(x)) -#define ROUND_UP_2(x) ROUND_UP_X(x, 1) -#define ROUND_UP_4(x) ROUND_UP_X(x, 2) -#define ROUND_UP_8(x) ROUND_UP_X(x, 3) -#define DIV_ROUND_UP_X(v, x) (((v) + GEN_MASK(x)) >> (x)) - -typedef struct PixFmtInfo { - uint8_t x_chroma_shift; - uint8_t y_chroma_shift; -} PixFmtInfo; - -static PixFmtInfo pix_fmt_info[PIX_FMT_NB]; - -/* define debug channel */ -MULTI_DEBUG_CHANNEL(qemu, marucodec); - -void codec_thread_init(SVCodecState *s) -{ - int index = 0; - QemuThread *pthread = NULL; - TRACE("Enter, %s\n", __func__); - - pthread = g_malloc0(sizeof(QemuThread) * CODEC_MAX_THREAD); - if (!pthread) { - ERR("Failed to allocate wrk_thread memory.\n"); - return; - } - qemu_cond_init(&s->codec_thread.cond); - qemu_mutex_init(&s->codec_thread.mutex); - - qemu_mutex_lock(&s->thread_mutex); - s->isrunning = 1; - qemu_mutex_unlock(&s->thread_mutex); - - for (; index < CODEC_MAX_THREAD; index++) { - qemu_thread_create(&pthread[index], codec_worker_thread, (void *)s, - QEMU_THREAD_JOINABLE); - } - - s->codec_thread.wrk_thread = pthread; - TRACE("Leave, %s\n", __func__); -} - -void codec_thread_exit(SVCodecState *s) -{ - TRACE("Enter, %s\n", __func__); - int index; - - /* stop to run dedicated threads. */ - s->isrunning = 0; - - for (index = 0; index < CODEC_MAX_THREAD; index++) { - qemu_thread_join(&s->codec_thread.wrk_thread[index]); - } - - TRACE("destroy mutex and conditional.\n"); - qemu_mutex_destroy(&s->codec_thread.mutex); - qemu_cond_destroy(&s->codec_thread.cond); - - TRACE("Leave, %s\n", __func__); -} - -void wake_codec_worker_thread(SVCodecState *s) -{ - TRACE("Enter, %s\n", __func__); - - qemu_cond_signal(&s->codec_thread.cond); - TRACE("sent a conditional signal to a worker thread.\n"); - - TRACE("Leave, %s\n", __func__); -} - -void *codec_worker_thread(void *opaque) -{ - SVCodecState *s = (SVCodecState *)opaque; - QemuThread thread; - AVCodecContext *avctx; - - TRACE("Enter, %s\n", __func__); - qemu_mutex_lock(&s->thread_mutex); - - while (s->isrunning) { - TRACE("wait for conditional signal.\n"); - qemu_cond_wait(&s->codec_thread.cond, &s->thread_mutex); - - qemu_thread_get_self(&thread); -#ifdef CONFIG_LINUX - TRACE("wake up a worker thread. :%x\n", thread.thread); -#endif - avctx = s->codec_ctx[s->codec_param.ctx_index].avctx; - if (avctx) { - if (avctx->codec->decode) { - decode_codec(s); - } else { - encode_codec(s); - } - } else { - ERR("there is a synchrous problem " - "between each context.\n"); - continue; - } - - s->codec_thread.state = MARU_CODEC_IRQ; - qemu_bh_schedule(s->tx_bh); - } - qemu_mutex_unlock(&s->thread_mutex); - TRACE("Leave, %s\n", __func__); - - return NULL; -} - -int decode_codec(SVCodecState *s) -{ - AVCodecContext *avctx; - uint32_t len = 0, ctx_index; - - TRACE("Enter, %s\n", __func__); - - qemu_mutex_lock(&s->codec_thread.mutex); - ctx_index = s->codec_param.ctx_index; - qemu_mutex_unlock(&s->codec_thread.mutex); - - avctx = s->codec_ctx[ctx_index].avctx; - if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) { - len = qemu_avcodec_decode_video(s, ctx_index); - } else { - len = qemu_avcodec_decode_audio(s, ctx_index); - } - - TRACE("Leave, %s\n", __func__); - return len; -} - -int encode_codec(SVCodecState *s) -{ - AVCodecContext *avctx; - uint32_t len = 0, ctx_index; - - TRACE("Enter, %s\n", __func__); - - qemu_mutex_unlock(&s->thread_mutex); - - ctx_index = s->codec_param.ctx_index; - avctx = s->codec_ctx[ctx_index].avctx; - if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) { - len = qemu_avcodec_encode_video(s, ctx_index); - } else { - len = qemu_avcodec_encode_audio(s, ctx_index); - } - - qemu_mutex_lock(&s->thread_mutex); - - TRACE("Leave, %s\n", __func__); - return len; -} - -static int qemu_serialize_rational(const AVRational *elem, uint8_t *buff) -{ - int size = 0; - - memcpy(buff + size, &elem->num, sizeof(elem->num)); - size += sizeof(elem->num); - memcpy(buff + size, &elem->den, sizeof(elem->den)); - size += sizeof(elem->den); - - return size; -} - -static int qemu_deserialize_rational(const uint8_t *buff, AVRational *elem) -{ - int size = 0; - - memset(elem, 0, sizeof(*elem)); - - memcpy(&elem->num, buff + size, sizeof(elem->num)); - size += sizeof(elem->num); - memcpy(&elem->den, buff + size, sizeof(elem->den)); - size += sizeof(elem->den); - - return size; -} - -static int qemu_serialize_frame(const AVFrame *elem, uint8_t *buff) -{ - int size = 0; - - memcpy(buff + size, &elem->key_frame, sizeof(elem->key_frame)); - size += sizeof(elem->key_frame); - memcpy(buff + size, &elem->pict_type, sizeof(elem->pict_type)); - size += sizeof(elem->pict_type); - memcpy(buff + size, &elem->pts, sizeof(elem->pts)); - size += sizeof(elem->pts); - memcpy(buff + size, &elem->coded_picture_number, - sizeof(elem->coded_picture_number)); - size += sizeof(elem->coded_picture_number); - memcpy(buff + size, &elem->display_picture_number, - sizeof(elem->display_picture_number)); - size += sizeof(elem->display_picture_number); - memcpy(buff + size, &elem->quality, sizeof(elem->quality)); - size += sizeof(elem->quality); - memcpy(buff + size, &elem->age, sizeof(elem->age)); - size += sizeof(elem->age); - memcpy(buff + size, &elem->reference, sizeof(elem->reference)); - size += sizeof(elem->reference); - memcpy(buff + size, &elem->reordered_opaque, - sizeof(elem->reordered_opaque)); - size += sizeof(elem->reordered_opaque); - memcpy(buff + size, &elem->repeat_pict, sizeof(elem->repeat_pict)); - size += sizeof(elem->repeat_pict); - memcpy(buff + size, &elem->interlaced_frame, - sizeof(elem->interlaced_frame)); - size += sizeof(elem->interlaced_frame); - - return size; -} - -static int qemu_deserialize_frame(const uint8_t *buff, AVFrame *elem) -{ - int size = 0; - - memset(elem, 0, sizeof(*elem)); - - memcpy(&elem->linesize, buff + size, sizeof(elem->linesize)); - size += sizeof(elem->linesize); - memcpy(&elem->key_frame, buff + size, sizeof(elem->key_frame)); - size += sizeof(elem->key_frame); - memcpy(&elem->pict_type, buff + size, sizeof(elem->pict_type)); - size += sizeof(elem->pict_type); - memcpy(&elem->pts, buff + size, sizeof(elem->pts)); - size += sizeof(elem->pts); - memcpy(&elem->coded_picture_number, buff + size, - sizeof(elem->coded_picture_number)); - size += sizeof(elem->coded_picture_number); - memcpy(&elem->display_picture_number, buff + size, - sizeof(elem->display_picture_number)); - size += sizeof(elem->display_picture_number); - memcpy(&elem->quality, buff + size, sizeof(elem->quality)); - size += sizeof(elem->quality); - memcpy(&elem->age, buff + size, sizeof(elem->age)); - size += sizeof(elem->age); - memcpy(&elem->reference, buff + size, sizeof(elem->reference)); - size += sizeof(elem->reference); - memcpy(&elem->qstride, buff + size, sizeof(elem->qstride)); - size += sizeof(elem->qstride); - memcpy(&elem->motion_subsample_log2, buff + size, - sizeof(elem->motion_subsample_log2)); - size += sizeof(elem->motion_subsample_log2); - memcpy(&elem->error, buff + size, sizeof(elem->error)); - size += sizeof(elem->error); - memcpy(&elem->type, buff + size, sizeof(elem->type)); - size += sizeof(elem->type); - memcpy(&elem->repeat_pict, buff + size, sizeof(elem->repeat_pict)); - size += sizeof(elem->repeat_pict); - memcpy(&elem->qscale_type, buff + size, sizeof(elem->qscale_type)); - size += sizeof(elem->qscale_type); - memcpy(&elem->interlaced_frame, buff + size, - sizeof(elem->interlaced_frame)); - size += sizeof(elem->interlaced_frame); - memcpy(&elem->top_field_first, buff + size, sizeof(elem->top_field_first)); - size += sizeof(elem->top_field_first); - memcpy(&elem->palette_has_changed, buff + size, - sizeof(elem->palette_has_changed)); - size += sizeof(elem->palette_has_changed); - memcpy(&elem->buffer_hints, buff + size, sizeof(elem->buffer_hints)); - size += sizeof(elem->buffer_hints); - memcpy(&elem->reordered_opaque, buff + size, - sizeof(elem->reordered_opaque)); - size += sizeof(elem->reordered_opaque); - - return size; -} - -void qemu_parser_init(SVCodecState *s, int ctx_index) -{ - TRACE("[%s] Enter\n", __func__); - - s->codec_ctx[ctx_index].parser_buf = NULL; - s->codec_ctx[ctx_index].parser_use = false; - - TRACE("[%s] Leave\n", __func__); -} - -void qemu_reset_codec_info(SVCodecState *s, uint32_t value) -{ - int ctx_idx; - - TRACE("[%s] Enter\n", __func__); - qemu_mutex_lock(&s->thread_mutex); - - for (ctx_idx = 0; ctx_idx < CODEC_CONTEXT_MAX; ctx_idx++) { - if (s->codec_ctx[ctx_idx].file_index == value) { - TRACE("reset %d context\n", ctx_idx); - qemu_mutex_unlock(&s->thread_mutex); - qemu_av_free(s, ctx_idx); - qemu_mutex_lock(&s->thread_mutex); - s->codec_ctx[ctx_idx].avctx_use = false; - break; - } - } - qemu_parser_init(s, ctx_idx); - - qemu_mutex_unlock(&s->thread_mutex); - TRACE("[%s] Leave\n", __func__); -} - -/* void av_register_all() */ -void qemu_av_register_all(void) -{ - av_register_all(); - TRACE("av_register_all\n"); -} - -/* int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic) */ -int qemu_avcodec_get_buffer(AVCodecContext *context, AVFrame *picture) -{ - int ret; - TRACE("avcodec_default_get_buffer\n"); - - picture->reordered_opaque = context->reordered_opaque; - picture->opaque = NULL; - - ret = avcodec_default_get_buffer(context, picture); - - return ret; -} - -/* void avcodec_default_release_buffer(AVCodecContext *ctx, AVFrame *frame) */ -void qemu_avcodec_release_buffer(AVCodecContext *context, AVFrame *picture) -{ - TRACE("avcodec_default_release_buffer\n"); - avcodec_default_release_buffer(context, picture); -} - -static void qemu_init_pix_fmt_info(void) -{ - /* YUV formats */ - pix_fmt_info[PIX_FMT_YUV420P].x_chroma_shift = 1; - pix_fmt_info[PIX_FMT_YUV420P].y_chroma_shift = 1; - - pix_fmt_info[PIX_FMT_YUV422P].x_chroma_shift = 1; - pix_fmt_info[PIX_FMT_YUV422P].y_chroma_shift = 0; - - pix_fmt_info[PIX_FMT_YUV444P].x_chroma_shift = 1; - pix_fmt_info[PIX_FMT_YUV444P].y_chroma_shift = 0; - - pix_fmt_info[PIX_FMT_YUYV422].x_chroma_shift = 1; - pix_fmt_info[PIX_FMT_YUYV422].y_chroma_shift = 0; - - pix_fmt_info[PIX_FMT_YUV410P].x_chroma_shift = 2; - pix_fmt_info[PIX_FMT_YUV410P].y_chroma_shift = 2; - - pix_fmt_info[PIX_FMT_YUV411P].x_chroma_shift = 2; - pix_fmt_info[PIX_FMT_YUV411P].y_chroma_shift = 0; - - /* JPEG YUV */ - pix_fmt_info[PIX_FMT_YUVJ420P].x_chroma_shift = 1; - pix_fmt_info[PIX_FMT_YUVJ420P].y_chroma_shift = 1; - - pix_fmt_info[PIX_FMT_YUVJ422P].x_chroma_shift = 1; - pix_fmt_info[PIX_FMT_YUVJ422P].y_chroma_shift = 0; - - pix_fmt_info[PIX_FMT_YUVJ444P].x_chroma_shift = 0; - pix_fmt_info[PIX_FMT_YUVJ444P].y_chroma_shift = 0; - - /* RGB formats */ - pix_fmt_info[PIX_FMT_RGB24].x_chroma_shift = 0; - pix_fmt_info[PIX_FMT_RGB24].y_chroma_shift = 0; - - pix_fmt_info[PIX_FMT_BGR24].x_chroma_shift = 0; - pix_fmt_info[PIX_FMT_BGR24].y_chroma_shift = 0; - - pix_fmt_info[PIX_FMT_RGB32].x_chroma_shift = 0; - pix_fmt_info[PIX_FMT_RGB32].y_chroma_shift = 0; - - pix_fmt_info[PIX_FMT_RGB565].x_chroma_shift = 0; - pix_fmt_info[PIX_FMT_RGB565].y_chroma_shift = 0; - - pix_fmt_info[PIX_FMT_RGB555].x_chroma_shift = 0; - pix_fmt_info[PIX_FMT_RGB555].y_chroma_shift = 0; - - pix_fmt_info[PIX_FMT_YUVA420P].x_chroma_shift = 1, - pix_fmt_info[PIX_FMT_YUVA420P].y_chroma_shift = 1; -} - -static uint8_t *qemu_malloc_avpicture (int picture_size) -{ - uint8_t *ptr = NULL; - - ptr = av_mallocz(picture_size); - if (!ptr) { - ERR("failed to allocate memory.\n"); - return NULL; - } - - return ptr; -} - -static int qemu_avpicture_fill(AVPicture *picture, uint8_t *ptr, - int pix_fmt, int width, - int height, bool encode) -{ - int size, w2, h2, size2; - int stride, stride2; - int fsize; - PixFmtInfo *pinfo; - - pinfo = &pix_fmt_info[pix_fmt]; - - switch (pix_fmt) { - case PIX_FMT_YUV420P: - case PIX_FMT_YUV422P: - case PIX_FMT_YUV444P: - case PIX_FMT_YUV410P: - case PIX_FMT_YUV411P: - case PIX_FMT_YUVJ420P: - case PIX_FMT_YUVJ422P: - case PIX_FMT_YUVJ444P: - stride = ROUND_UP_4(width); - h2 = ROUND_UP_X(height, pinfo->y_chroma_shift); - size = stride * h2; - w2 = DIV_ROUND_UP_X(width, pinfo->x_chroma_shift); - stride2 = ROUND_UP_4(w2); - h2 = DIV_ROUND_UP_X(height, pinfo->y_chroma_shift); - size2 = stride2 * h2; - fsize = size + 2 * size2; - TRACE("stride: %d, stride2: %d, size: %d, size2: %d, fsize: %d\n", - stride, stride2, size, size2, fsize); - if (!encode && !ptr) { - ptr = qemu_malloc_avpicture(fsize); - } - picture->data[0] = ptr; - picture->data[1] = picture->data[0] + size; - picture->data[2] = picture->data[1] + size2; - picture->data[3] = NULL; - picture->linesize[0] = stride; - picture->linesize[1] = stride2; - picture->linesize[2] = stride2; - picture->linesize[3] = 0; - TRACE("planes %d %d %d\n", 0, size, size + size2); - TRACE("strides %d %d %d\n", stride, stride2, stride2); - break; - case PIX_FMT_YUVA420P: - stride = ROUND_UP_4 (width); - h2 = ROUND_UP_X (height, pinfo->y_chroma_shift); - size = stride * h2; - w2 = DIV_ROUND_UP_X (width, pinfo->x_chroma_shift); - stride2 = ROUND_UP_4 (w2); - h2 = DIV_ROUND_UP_X (height, pinfo->y_chroma_shift); - size2 = stride2 * h2; - fsize = 2 * size + 2 * size2; - TRACE("stride %d, stride2 %d, size %d, size2 %d, fsize %d\n", - stride, stride2, size, size2, fsize); - if (!encode && !ptr) { - ptr = qemu_malloc_avpicture(fsize); - } - picture->data[0] = ptr; - picture->data[1] = picture->data[0] + size; - picture->data[2] = picture->data[1] + size2; - picture->data[3] = picture->data[2] + size2; - picture->linesize[0] = stride; - picture->linesize[1] = stride2; - picture->linesize[2] = stride2; - picture->linesize[3] = stride; - TRACE("planes %d %d %d %d\n", 0, size, size + size2, size + 2 * size2); - TRACE("strides %d %d %d %d\n", stride, stride2, stride2, stride); - break; - case PIX_FMT_RGB24: - case PIX_FMT_BGR24: - stride = ROUND_UP_4 (width * 3); - fsize = stride * height; - TRACE("stride: %d, fsize: %d\n", stride, fsize); - if (!encode && !ptr) { - ptr = qemu_malloc_avpicture(fsize); - } - picture->data[0] = ptr; - picture->data[1] = NULL; - picture->data[2] = NULL; - picture->data[3] = NULL; - picture->linesize[0] = stride; - picture->linesize[1] = 0; - picture->linesize[2] = 0; - picture->linesize[3] = 0; - break; - case PIX_FMT_RGB32: - stride = width * 4; - fsize = stride * height; - TRACE("stride: %d, fsize: %d\n", stride, fsize); - if (!encode && !ptr) { - ptr = qemu_malloc_avpicture(fsize); - } - picture->data[0] = ptr; - picture->data[1] = NULL; - picture->data[2] = NULL; - picture->data[3] = NULL; - picture->linesize[0] = stride; - picture->linesize[1] = 0; - picture->linesize[2] = 0; - picture->linesize[3] = 0; - break; - case PIX_FMT_RGB555: - case PIX_FMT_RGB565: - case PIX_FMT_YUYV422: - case PIX_FMT_UYVY422: - stride = ROUND_UP_4 (width * 2); - fsize = stride * height; - TRACE("stride: %d, fsize: %d\n", stride, fsize); - if (!encode && !ptr) { - ptr = qemu_malloc_avpicture(fsize); - } - picture->data[0] = ptr; - picture->data[1] = NULL; - picture->data[2] = NULL; - picture->data[3] = NULL; - picture->linesize[0] = stride; - picture->linesize[1] = 0; - picture->linesize[2] = 0; - picture->linesize[3] = 0; - break; - case PIX_FMT_UYYVYY411: - /* FIXME, probably not the right stride */ - stride = ROUND_UP_4 (width); - size = stride * height; - fsize = size + size / 2; - TRACE("stride %d, size %d, fsize %d\n", stride, size, fsize); - if (!encode && !ptr) { - ptr = qemu_malloc_avpicture(fsize); - } - picture->data[0] = ptr; - picture->data[1] = NULL; - picture->data[2] = NULL; - picture->data[3] = NULL; - picture->linesize[0] = width + width / 2; - picture->linesize[1] = 0; - picture->linesize[2] = 0; - picture->linesize[3] = 0; - break; - case PIX_FMT_GRAY8: - stride = ROUND_UP_4 (width); - fsize = stride * height; - TRACE("stride %d, fsize %d\n", stride, fsize); - if (!encode && !ptr) { - ptr = qemu_malloc_avpicture(fsize); - } - picture->data[0] = ptr; - picture->data[1] = NULL; - picture->data[2] = NULL; - picture->data[3] = NULL; - picture->linesize[0] = stride; - picture->linesize[1] = 0; - picture->linesize[2] = 0; - picture->linesize[3] = 0; - break; - case PIX_FMT_MONOWHITE: - case PIX_FMT_MONOBLACK: - stride = ROUND_UP_4 ((width + 7) >> 3); - fsize = stride * height; - TRACE("stride %d, fsize %d\n", stride, fsize); - if (!encode && !ptr) { - ptr = qemu_malloc_avpicture(fsize); - } - picture->data[0] = ptr; - picture->data[1] = NULL; - picture->data[2] = NULL; - picture->data[3] = NULL; - picture->linesize[0] = stride; - picture->linesize[1] = 0; - picture->linesize[2] = 0; - picture->linesize[3] = 0; - break; - case PIX_FMT_PAL8: - /* already forced to be with stride, so same result as other function */ - stride = ROUND_UP_4 (width); - size = stride * height; - fsize = size + 256 * 4; - TRACE("stride %d, size %d, fsize %d\n", stride, size, fsize); - if (!encode && !ptr) { - ptr = qemu_malloc_avpicture(fsize); - } - picture->data[0] = ptr; - picture->data[1] = ptr + size; /* palette is stored here as 256 32 bit words */ - picture->data[2] = NULL; - picture->data[3] = NULL; - picture->linesize[0] = stride; - picture->linesize[1] = 4; - picture->linesize[2] = 0; - picture->linesize[3] = 0; - break; - default: - picture->data[0] = NULL; - picture->data[1] = NULL; - picture->data[2] = NULL; - picture->data[3] = NULL; - fsize = -1; - ERR("pixel format: %d was wrong.\n", pix_fmt); - break; - } - - return fsize; -} - -/* int avcodec_open(AVCodecContext *avctx, AVCodec *codec) */ -int qemu_avcodec_open(SVCodecState *s) -{ - AVCodecContext *avctx; - AVCodec *codec; - enum CodecID codec_id; - off_t offset; - int ret = -1; - int bEncode = 0; - int size = 0; - int ctx_index = 0; - - av_register_all(); - TRACE("av_register_all\n"); - - ctx_index = qemu_avcodec_alloc_context(s); - if (ctx_index < 0) { - return ret; - } - - qemu_mutex_lock(&s->thread_mutex); - offset = s->codec_param.mmap_offset; - qemu_mutex_unlock(&s->thread_mutex); - - avctx = s->codec_ctx[ctx_index].avctx; - if (!avctx) { - ERR("[%s] %d of AVCodecContext is NULL!\n", __func__, ctx_index); - qemu_mutex_unlock(&s->thread_mutex); - return ret; - } - - TRACE("[%s] Context Index:%d, offset:%d\n", __func__, ctx_index, offset); - memcpy(&avctx->bit_rate, (uint8_t *)s->vaddr + offset, sizeof(int)); - size = sizeof(int); - memcpy(&avctx->bit_rate_tolerance, - (uint8_t *)s->vaddr + offset + size, sizeof(int)); - size += sizeof(int); - memcpy(&avctx->flags, (uint8_t *)s->vaddr + offset + size, sizeof(int)); - size += sizeof(int); - size += qemu_deserialize_rational((uint8_t *)s->vaddr + offset + size, - &avctx->time_base); - memcpy(&avctx->width, (uint8_t *)s->vaddr + offset + size, sizeof(int)); - size += sizeof(int); - memcpy(&avctx->height, (uint8_t *)s->vaddr + offset + size, sizeof(int)); - size += sizeof(int); - memcpy(&avctx->gop_size, (uint8_t *)s->vaddr + offset + size, sizeof(int)); - size += sizeof(int); - memcpy(&avctx->pix_fmt, (uint8_t *)s->vaddr + offset + size, sizeof(int)); - size += sizeof(int); - memcpy(&avctx->sample_rate, - (uint8_t *)s->vaddr + offset + size, sizeof(int)); - size += sizeof(int); - memcpy(&avctx->channels, (uint8_t *)s->vaddr + offset + size, sizeof(int)); - size += sizeof(int); - memcpy(&avctx->codec_tag, (uint8_t *)s->vaddr + offset + size, sizeof(int)); - size += sizeof(int); - memcpy(&avctx->block_align, - (uint8_t *)s->vaddr + offset + size, sizeof(int)); - size += sizeof(int); - memcpy(&avctx->rc_strategy, - (uint8_t *)s->vaddr + offset + size, sizeof(int)); - size += sizeof(int); - memcpy(&avctx->strict_std_compliance, - (uint8_t *)s->vaddr + offset + size, sizeof(int)); - size += sizeof(int); - memcpy(&avctx->rc_qsquish, - (uint8_t *)s->vaddr + offset + size, sizeof(float)); - size += sizeof(float); - size += qemu_deserialize_rational((uint8_t *)s->vaddr + offset + size, - &avctx->sample_aspect_ratio); - memcpy(&avctx->qmin, (uint8_t *)s->vaddr + offset + size, sizeof(int)); - size += sizeof(int); - memcpy(&avctx->qmax, (uint8_t *)s->vaddr + offset + size, sizeof(int)); - size += sizeof(int); - memcpy(&avctx->pre_me, (uint8_t *)s->vaddr + offset + size, sizeof(int)); - size += sizeof(int); - memcpy(&avctx->trellis, (uint8_t *)s->vaddr + offset + size, sizeof(int)); - size += sizeof(int); - memcpy(&avctx->extradata_size, - (uint8_t *)s->vaddr + offset + size, sizeof(int)); - size += sizeof(int); - memcpy(&codec_id, (uint8_t *)s->vaddr + offset + size, sizeof(int)); - size += sizeof(int); - memcpy(&bEncode, (uint8_t *)s->vaddr + offset + size, sizeof(int)); - size += sizeof(int); - TRACE("Context Index:%d, width:%d, height:%d\n", - ctx_index, avctx->width, avctx->height); - - if (avctx->extradata_size > 0) { - avctx->extradata = (uint8_t *)av_mallocz(avctx->extradata_size + - ROUND_UP_X(FF_INPUT_BUFFER_PADDING_SIZE, 4)); - memcpy(avctx->extradata, - (uint8_t *)s->vaddr + offset + size, avctx->extradata_size); - size += avctx->extradata_size; - } else { - TRACE("[%s] allocate dummy extradata\n", __func__); - avctx->extradata = - av_mallocz(ROUND_UP_X(FF_INPUT_BUFFER_PADDING_SIZE, 4)); - } - - if (bEncode) { - TRACE("[%s] find encoder :%d\n", __func__, codec_id); - codec = avcodec_find_encoder(codec_id); - } else { - TRACE("[%s] find decoder :%d\n", __func__, codec_id); - codec = avcodec_find_decoder(codec_id); - } - - if (!codec) { - ERR("[%s] failed to find codec of %d\n", __func__, codec_id); - } - - if (codec->type == AVMEDIA_TYPE_AUDIO) { - s->codec_ctx[ctx_index].mem_index = s->codec_param.mem_index; - TRACE("set mem_index: %d into ctx_index: %d.\n", - s->codec_ctx[ctx_index].mem_index, ctx_index); - } - -#if 0 - avctx->get_buffer = qemu_avcodec_get_buffer; - avctx->release_buffer = qemu_avcodec_release_buffer; -#endif - - ret = avcodec_open(avctx, codec); - if (ret != 0) { - ERR("[%s] avcodec_open failure, %d\n", __func__, ret); - } - - memcpy((uint8_t *)s->vaddr + offset, &ctx_index, sizeof(int)); - size = sizeof(int); - memcpy((uint8_t *)s->vaddr + offset + size, &avctx->pix_fmt, sizeof(int)); - size += sizeof(int); - size += qemu_serialize_rational(&avctx->time_base, - (uint8_t *)s->vaddr + offset + size); - memcpy((uint8_t *)s->vaddr + offset + size, &avctx->channels, sizeof(int)); - size += sizeof(int); - memcpy((uint8_t *)s->vaddr + offset + size, - &avctx->sample_fmt, sizeof(int)); - size += sizeof(int); - memcpy((uint8_t *)s->vaddr + offset + size, - &avctx->codec_type, sizeof(int)); - size += sizeof(int); - memcpy((uint8_t *)s->vaddr + offset + size, &avctx->codec_id, sizeof(int)); - size += sizeof(int); - memcpy((uint8_t *)s->vaddr + offset + size, - &avctx->coded_width, sizeof(int)); - size += sizeof(int); - memcpy((uint8_t *)s->vaddr + offset + size, - &avctx->coded_height, sizeof(int)); - size += sizeof(int); - memcpy((uint8_t *)s->vaddr + offset + size, - &avctx->ticks_per_frame, sizeof(int)); - size += sizeof(int); - memcpy((uint8_t *)s->vaddr + offset + size, - &avctx->chroma_sample_location, sizeof(int)); - size += sizeof(int); -#if 0 - memcpy((uint8_t *)s->vaddr + offset + size, - avctx->priv_data, codec->priv_data_size); - size += codec->priv_data_size; -#endif - memcpy((uint8_t *)s->vaddr + offset + size, &ret, sizeof(int)); - size += sizeof(int); - - TRACE("Leave, %s\n", __func__); - return ret; -} - -/* int avcodec_close(AVCodecContext *avctx) */ -int qemu_avcodec_close(SVCodecState *s, int ctx_index) -{ - AVCodecContext *avctx; - off_t offset; - int ret = -1; - - TRACE("Enter, %s\n", __func__); - qemu_mutex_lock(&s->thread_mutex); - - offset = s->codec_param.mmap_offset; - - avctx = s->codec_ctx[ctx_index].avctx; - if (!avctx) { - ERR("[%s] %d of AVCodecContext is NULL\n", __func__, ctx_index); - memcpy((uint8_t *)s->vaddr + offset, &ret, sizeof(int)); - qemu_mutex_unlock(&s->thread_mutex); - return ret; - } - - ret = avcodec_close(avctx); - TRACE("after avcodec_close. ret:%d\n", ret); - - memcpy((uint8_t *)s->vaddr + offset, &ret, sizeof(int)); - - qemu_mutex_unlock(&s->thread_mutex); - - TRACE("[%s] Leave\n", __func__); - return ret; -} - -/* AVCodecContext* avcodec_alloc_context (void) */ -int qemu_avcodec_alloc_context(SVCodecState *s) -{ - int index; - - TRACE("[%s] Enter\n", __func__); - - for (index = 0; index < CODEC_CONTEXT_MAX; index++) { - if (s->codec_ctx[index].avctx_use == false) { - TRACE("Succeeded to get %d of context.\n", index); - s->codec_ctx[index].avctx_use = true; - break; - } - TRACE("Failed to get context.\n"); - } - - if (index == CODEC_CONTEXT_MAX) { - ERR("Failed to get available codec context."); - ERR(" Try to run codec again.\n"); - return -1; - } - - TRACE("allocate %d of context and frame.\n", index); - s->codec_ctx[index].avctx = avcodec_alloc_context(); - s->codec_ctx[index].frame = avcodec_alloc_frame(); - - s->codec_ctx[index].file_index = s->codec_param.file_index; - qemu_parser_init(s, index); - qemu_init_pix_fmt_info(); - - TRACE("[%s] Leave\n", __func__); - - return index; -} - -/* void av_free(void *ptr) */ -void qemu_av_free(SVCodecState *s, int ctx_index) -{ - AVCodecContext *avctx; - AVFrame *avframe; - - TRACE("enter %s\n", __func__); - qemu_mutex_lock(&s->thread_mutex); - - avctx = s->codec_ctx[ctx_index].avctx; - avframe = s->codec_ctx[ctx_index].frame; - - if (avctx && avctx->palctrl) { - av_free(avctx->palctrl); - avctx->palctrl = NULL; - } - - if (avctx && avctx->extradata) { - TRACE("free extradata\n"); - av_free(avctx->extradata); - avctx->extradata = NULL; - } - - if (avctx && avctx->codec_type == AVMEDIA_TYPE_AUDIO) { - int audio_idx = s->codec_ctx[ctx_index].mem_index; - TRACE("reset audio mem_idex: %d\n", __LINE__, audio_idx); - s->audio_codec_offset[audio_idx] = 0; - } - - if (avctx) { - TRACE("free codec context of %d.\n", ctx_index); - av_free(avctx); - s->codec_ctx[ctx_index].avctx = NULL; - } - - if (avframe) { - TRACE("free codec frame of %d.\n", ctx_index); - av_free(avframe); - s->codec_ctx[ctx_index].frame = NULL; - } - - qemu_mutex_unlock(&s->thread_mutex); - TRACE("leave %s\n", __func__); -} - -/* void avcodec_flush_buffers(AVCodecContext *avctx) */ -void qemu_avcodec_flush_buffers(SVCodecState *s, int ctx_index) -{ - AVCodecContext *avctx; - - TRACE("Enter\n"); - qemu_mutex_lock(&s->thread_mutex); - - avctx = s->codec_ctx[ctx_index].avctx; - if (avctx) { - avcodec_flush_buffers(avctx); - } else { - ERR("[%s] %d of AVCodecContext is NULL\n", __func__, ctx_index); - } - - qemu_mutex_unlock(&s->thread_mutex); - TRACE("[%s] Leave\n", __func__); -} - -/* int avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture, - * int *got_picture_ptr, const uint8_t *buf, - * int buf_size) - */ -int qemu_avcodec_decode_video(SVCodecState *s, int ctx_index) -{ - AVCodecContext *avctx; - AVFrame *picture; - AVPacket avpkt; - int got_picture_ptr; - uint8_t *buf; - uint8_t *parser_buf; - bool parser_use; - int buf_size; - int size = 0; - int ret = -1; - off_t offset; - - TRACE("Enter, %s\n", __func__); - qemu_mutex_lock(&s->codec_thread.mutex); - - TRACE("[%s] Video Context Index : %d\n", __func__, ctx_index); - - avctx = s->codec_ctx[ctx_index].avctx; - picture = s->codec_ctx[ctx_index].frame; - if (!avctx || !picture) { - ERR("[%s] %d of Context or Frame is NULL!\n", __func__, ctx_index); - qemu_mutex_unlock(&s->codec_thread.mutex); - return ret; - } - - offset = s->codec_param.mmap_offset; - - parser_buf = s->codec_ctx[ctx_index].parser_buf; - parser_use = s->codec_ctx[ctx_index].parser_use; - TRACE("[%s] Parser Buffer : %p, Parser:%d\n", __func__, - parser_buf, parser_use); - - memcpy(&avctx->reordered_opaque, - (uint8_t *)s->vaddr + offset, sizeof(int64_t)); - size = sizeof(int64_t); - memcpy(&avctx->skip_frame, - (uint8_t *)s->vaddr + offset + size, sizeof(int)); - size += sizeof(int); - memcpy(&buf_size, (uint8_t *)s->vaddr + offset + size, sizeof(int)); - size += sizeof(int); - - picture->reordered_opaque = avctx->reordered_opaque; - - if (parser_buf && parser_use) { - buf = parser_buf; - } else if (buf_size > 0) { - TRACE("[%s] not use parser, codec_id:%x\n", __func__, avctx->codec_id); - buf = (uint8_t *)s->vaddr + offset + size; - size += buf_size; - } else { - TRACE("There is no input buffer\n"); - buf = NULL; - } - - memset(&avpkt, 0, sizeof(AVPacket)); - avpkt.data = buf; - avpkt.size = buf_size; - TRACE("packet buf:%p, size:%d\n", buf, buf_size); - - ret = avcodec_decode_video2(avctx, picture, &got_picture_ptr, &avpkt); - - TRACE("[%s] after decoding video, ret:%d\n", __func__, ret); - if (ret < 0) { - ERR("[%s] failed to decode video!!, ret:%d\n", __func__, ret); - } else { - if (ret == 0) { - TRACE("[%s] no frame. packet size:%d\n", __func__, avpkt.size); - } - TRACE("decoded frame number:%d\n", avctx->frame_number); - } - - memcpy((uint8_t *)s->vaddr + offset, &avctx->pix_fmt, sizeof(int)); - size = sizeof(int); - size += qemu_serialize_rational(&avctx->time_base, - (uint8_t *)s->vaddr + offset + size); - memcpy((uint8_t *)s->vaddr + offset + size, &avctx->width, sizeof(int)); - size += sizeof(int); - memcpy((uint8_t *)s->vaddr + offset + size, &avctx->height, sizeof(int)); - size += sizeof(int); - memcpy((uint8_t *)s->vaddr + offset + size, - &avctx->has_b_frames, sizeof(int)); - size += sizeof(int); - memcpy((uint8_t *)s->vaddr + offset + size, - &avctx->frame_number, sizeof(int)); - size += sizeof(int); - size += qemu_serialize_rational(&avctx->sample_aspect_ratio, - (uint8_t *)s->vaddr + offset + size); - memcpy((uint8_t *)s->vaddr + offset + size, - &avctx->internal_buffer_count, sizeof(int)); - size += sizeof(int); - memcpy((uint8_t *)s->vaddr + offset + size, &avctx->profile, sizeof(int)); - size += sizeof(int); - memcpy((uint8_t *)s->vaddr + offset + size, &avctx->level, sizeof(int)); - size += sizeof(int); - size += qemu_serialize_frame(picture, (uint8_t *)s->vaddr + offset + size); - - memcpy((uint8_t *)s->vaddr + offset + size, &got_picture_ptr, sizeof(int)); - size += sizeof(int); - memcpy((uint8_t *)s->vaddr + offset + size, &ret, sizeof(int)); - size += sizeof(int); - -#if 0 - memcpy((uint8_t *)s->vaddr + offset + size, dst.data[0], numbytes); - av_free(buffer); - - if (parser_buf && parser_use) { - TRACE("[%s] Free input buffer after decoding video\n", __func__); - TRACE("[%s] input buffer : %p, %p\n", - __func__, avpkt.data, parser_buf); - av_free(avpkt.data); - s->codec_ctx[ctx_index].parser_buf = NULL; - } -#endif - - qemu_mutex_unlock(&s->codec_thread.mutex); - TRACE("Leave, %s\n", __func__); - - return ret; -} - -/* int avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, - * int buf_size, const AVFrame *pict) - */ -int qemu_avcodec_encode_video(SVCodecState *s, int ctx_index) -{ - AVCodecContext *avctx = NULL; - AVFrame *pict = NULL; - uint8_t *inputBuf = NULL; - int outbufSize = 0; - int bPict = -1; - int size = 0; - int ret = -1; - off_t offset; - - TRACE("Enter, %s\n", __func__); - qemu_mutex_lock(&s->codec_thread.mutex); - - avctx = s->codec_ctx[ctx_index].avctx; - pict = s->codec_ctx[ctx_index].frame; - if (!avctx || !pict) { - ERR("[%s] %d of Context or Frame is NULL\n", __func__, ctx_index); - qemu_mutex_unlock(&s->thread_mutex); - return ret; - } - - offset = s->codec_param.mmap_offset; - - size = sizeof(int); - memcpy(&bPict, (uint8_t *)s->vaddr + offset, size); - TRACE("[%s] avframe is :%d\n", __func__, bPict); - - if (bPict == 0) { - memcpy(&outbufSize, (uint8_t *)s->vaddr + offset + size, size); - size += sizeof(int); - size += - qemu_deserialize_frame((uint8_t *)s->vaddr + offset + size, pict); - - inputBuf = (uint8_t *)s->vaddr + offset + size; - if (!inputBuf) { - ERR("[%s] failed to get input buffer\n", __func__); - return ret; - } - - ret = qemu_avpicture_fill((AVPicture *)pict, inputBuf, avctx->pix_fmt, - avctx->width, avctx->height, true); - - if (ret < 0) { - ERR("after avpicture_fill, ret:%d\n", ret); - } - TRACE("before encode video, ticks_per_frame:%d, pts:%lld\n", - avctx->ticks_per_frame, pict->pts); - } else { - TRACE("flush encoded buffers\n"); - pict = NULL; - } - - ret = avcodec_encode_video(avctx, (uint8_t *)s->vaddr + offset, - outbufSize, pict); - TRACE("encode video, ret:%d, pts:%lld, outbuf size:%d\n", - ret, pict->pts, outbufSize); - - if (ret < 0) { - ERR("failed to encode video.\n"); - } - - memcpy((uint8_t *)s->vaddr + offset + outbufSize, &ret, sizeof(int)); - - qemu_mutex_unlock(&s->codec_thread.mutex); - TRACE("Leave, %s\n", __func__); - - return ret; -} - -/* - * int avcodec_decode_audio3(AVCodecContext *avctx, int16_t *samples, - * int *frame_size_ptr, AVPacket *avpkt) - */ -int qemu_avcodec_decode_audio(SVCodecState *s, int ctx_index) -{ - AVCodecContext *avctx; - AVPacket avpkt; - int16_t *samples; - int frame_size_ptr; - uint8_t *buf; - uint8_t *parser_buf; - bool parser_use; - int buf_size, outbuf_size; - int size; - int ret = -1; - off_t offset; - - TRACE("Enter, %s\n", __func__); - - TRACE("Audio Context Index : %d\n", ctx_index); - avctx = s->codec_ctx[ctx_index].avctx; - if (!avctx) { - ERR("[%s] %d of Context is NULL!\n", __func__, ctx_index); - qemu_mutex_unlock(&s->codec_thread.mutex); - return ret; - } - - if (!avctx->codec) { - ERR("[%s] %d of Codec is NULL\n", __func__, ctx_index); - qemu_mutex_unlock(&s->codec_thread.mutex); - return ret; - } - - offset = s->codec_param.mmap_offset; - - parser_buf = s->codec_ctx[ctx_index].parser_buf; - parser_use = s->codec_ctx[ctx_index].parser_use; - - memcpy(&buf_size, (uint8_t *)s->vaddr + offset, sizeof(int)); - size = sizeof(int); - if (parser_buf && parser_use) { - TRACE("[%s] use parser, buf:%p codec_id:%x\n", - __func__, parser_buf, avctx->codec_id); - buf = parser_buf; - } else if (buf_size > 0) { - TRACE("[%s] not use parser, codec_id:%x\n", __func__, avctx->codec_id); - buf = (uint8_t *)s->vaddr + offset + size; - size += buf_size; - } else { - TRACE("no input buffer\n"); - buf = NULL; - } - - av_init_packet(&avpkt); - avpkt.data = buf; - avpkt.size = buf_size; - - frame_size_ptr = AVCODEC_MAX_AUDIO_FRAME_SIZE; - outbuf_size = frame_size_ptr; - samples = av_malloc(frame_size_ptr); - - ret = avcodec_decode_audio3(avctx, samples, &frame_size_ptr, &avpkt); - TRACE("after decoding audio!, ret:%d\n", ret); - - memcpy((uint8_t *)s->vaddr + offset, &avctx->bit_rate, sizeof(int)); - size = sizeof(int); - memcpy((uint8_t *)s->vaddr + offset + size, - &avctx->sample_rate, sizeof(int)); - size += sizeof(int); - memcpy((uint8_t *)s->vaddr + offset + size, &avctx->channels, sizeof(int)); - size += sizeof(int); - memcpy((uint8_t *)s->vaddr + offset + size, - &avctx->channel_layout, sizeof(int64_t)); - size += sizeof(int64_t); - memcpy((uint8_t *)s->vaddr + offset + size, &avctx->sub_id, sizeof(int)); - size += sizeof(int); - memcpy((uint8_t *)s->vaddr + offset + size, - &avctx->frame_size, sizeof(int)); - size += sizeof(int); - memcpy((uint8_t *)s->vaddr + offset + size, - &avctx->frame_number, sizeof(int)); - size += sizeof(int); - memcpy((uint8_t *)s->vaddr + offset + size, samples, outbuf_size); - size += outbuf_size; - memcpy((uint8_t *)s->vaddr + offset + size, &frame_size_ptr, sizeof(int)); - size += sizeof(int); - memcpy((uint8_t *)s->vaddr + offset + size, &ret, sizeof(int)); - size += sizeof(int); - - TRACE("before free input buffer and output buffer!\n"); - if (samples) { - TRACE("release allocated audio buffer.\n"); - av_free(samples); - samples = NULL; - } - - if (parser_buf && parser_use) { - TRACE("[%s] free parser buf\n", __func__); - av_free(avpkt.data); - s->codec_ctx[ctx_index].parser_buf = NULL; - } - - TRACE("[%s] Leave\n", __func__); - - return ret; -} - -int qemu_avcodec_encode_audio(SVCodecState *s, int ctx_index) -{ - WARN("[%s] Does not support audio encoder using FFmpeg\n", __func__); - return 0; -} - -/* void av_picture_copy(AVPicture *dst, const AVPicture *src, - * enum PixelFormat pix_fmt, int width, int height) - */ -void qemu_av_picture_copy(SVCodecState *s, int ctx_index) -{ - AVCodecContext *avctx = NULL; - AVPicture dst; - AVPicture *src = NULL; - int numBytes = 0; - uint8_t *buffer = NULL; - off_t offset = 0; - - TRACE("Enter :%s\n", __func__); - qemu_mutex_lock(&s->thread_mutex); - - avctx = s->codec_ctx[ctx_index].avctx; - src = (AVPicture *)s->codec_ctx[ctx_index].frame; - if (!avctx && !src) { - ERR("[%s] %d of context or frame is NULL\n", __func__, ctx_index); - qemu_mutex_unlock(&s->thread_mutex); - return; - } - - offset = s->codec_param.mmap_offset; - - numBytes = qemu_avpicture_fill(&dst, NULL, avctx->pix_fmt, - avctx->width, avctx->height, false); - TRACE("after avpicture_fill: %d\n", numBytes); - if (numBytes < 0) { - ERR("picture size:%d is wrong.\n", numBytes); - qemu_mutex_unlock(&s->thread_mutex); - return; - } - - av_picture_copy(&dst, src, avctx->pix_fmt, avctx->width, avctx->height); - buffer = dst.data[0]; - memcpy((uint8_t *)s->vaddr + offset, buffer, numBytes); - TRACE("after copy image buffer from host to guest.\n"); - - if (buffer) { - TRACE("release allocated video frame.\n"); - av_free(buffer); - } - - qemu_mutex_unlock(&s->thread_mutex); - TRACE("Leave :%s\n", __func__); -} - -/* AVCodecParserContext *av_parser_init(int codec_id) */ -void qemu_av_parser_init(SVCodecState *s, int ctx_index) -{ - AVCodecParserContext *parser_ctx = NULL; - AVCodecContext *avctx; - - TRACE("Enter :%s\n", __func__); - qemu_mutex_lock(&s->thread_mutex); - - avctx = s->codec_ctx[ctx_index].avctx; - if (!avctx) { - ERR("[%s] %d of AVCodecContext is NULL!!\n", __func__, ctx_index); - qemu_mutex_unlock(&s->thread_mutex); - return; - } - - TRACE("before av_parser_init, codec_type:%d codec_id:%x\n", - avctx->codec_type, avctx->codec_id); - - parser_ctx = av_parser_init(avctx->codec_id); - if (parser_ctx) { - TRACE("[%s] using parser\n", __func__); - s->codec_ctx[ctx_index].parser_use = true; - } else { - TRACE("[%s] no parser\n", __func__); - s->codec_ctx[ctx_index].parser_use = false; - } - s->codec_ctx[ctx_index].parser_ctx = parser_ctx; - - qemu_mutex_unlock(&s->thread_mutex); - TRACE("[%s] Leave\n", __func__); -} - -/* int av_parser_parse(AVCodecParserContext *s, AVCodecContext *avctx, - * uint8_t **poutbuf, int *poutbuf_size, - * const uint8_t *buf, int buf_size, - * int64_t pts, int64_t dts) - */ -int qemu_av_parser_parse(SVCodecState *s, int ctx_index) -{ - AVCodecParserContext *parser_ctx = NULL; - AVCodecContext *avctx = NULL; - uint8_t *poutbuf; - int poutbuf_size = 0; - uint8_t *inbuf = NULL; - int inbuf_size; - int64_t pts; - int64_t dts; - int64_t pos; - int size, ret = -1; - off_t offset; - - TRACE("Enter %s\n", __func__); - qemu_mutex_lock(&s->thread_mutex); - - parser_ctx = s->codec_ctx[ctx_index].parser_ctx; - avctx = s->codec_ctx[ctx_index].avctx; - if (!avctx) { - ERR("[%s] %d of AVCodecContext is NULL\n", __func__, ctx_index); - qemu_mutex_unlock(&s->thread_mutex); - return ret; - } - - if (!parser_ctx) { - ERR("[%s] %d of AVCodecParserContext is NULL\n", __func__, ctx_index); - qemu_mutex_unlock(&s->thread_mutex); - return ret; - } - - offset = s->codec_param.mmap_offset; - - memcpy(&parser_ctx->pts, - (uint8_t *)s->vaddr + offset, sizeof(int64_t)); - size = sizeof(int64_t); - memcpy(&parser_ctx->dts, - (uint8_t *)s->vaddr + offset + size, sizeof(int64_t)); - size += sizeof(int64_t); - memcpy(&parser_ctx->pos, - (uint8_t *)s->vaddr + offset + size, sizeof(int64_t)); - size += sizeof(int64_t); - memcpy(&pts, (uint8_t *)s->vaddr + offset + size, sizeof(int64_t)); - size += sizeof(int64_t); - memcpy(&dts, (uint8_t *)s->vaddr + offset + size, sizeof(int64_t)); - size += sizeof(int64_t); - memcpy(&pos, (uint8_t *)s->vaddr + offset + size, sizeof(int64_t)); - size += sizeof(int64_t); - memcpy(&inbuf_size, (uint8_t *)s->vaddr + offset + size, sizeof(int)); - size += sizeof(int); - - if (inbuf_size > 0) { - inbuf = av_mallocz(inbuf_size); - memcpy(inbuf, (uint8_t *)s->vaddr + offset + size, inbuf_size); - } else { - inbuf = NULL; - INFO("input buffer size for parser is zero.\n"); - } - - TRACE("[%s] inbuf:%p inbuf_size :%d\n", __func__, inbuf, inbuf_size); - ret = av_parser_parse2(parser_ctx, avctx, &poutbuf, &poutbuf_size, - inbuf, inbuf_size, pts, dts, pos); - TRACE("after parsing, outbuf size :%d, ret:%d\n", poutbuf_size, ret); - - if (poutbuf) { - s->codec_ctx[ctx_index].parser_buf = poutbuf; - } - - TRACE("[%s] inbuf : %p, outbuf : %p\n", __func__, inbuf, poutbuf); - memcpy((uint8_t *)s->vaddr + offset, &parser_ctx->pts, sizeof(int64_t)); - size = sizeof(int64_t); - memcpy((uint8_t *)s->vaddr + offset + size, &poutbuf_size, sizeof(int)); - size += sizeof(int); - memcpy((uint8_t *)s->vaddr + offset + size, &ret, sizeof(int)); - size += sizeof(int); - if (poutbuf && poutbuf_size > 0) { - memcpy((uint8_t *)s->vaddr + offset + size, poutbuf, poutbuf_size); - } else { - av_free(inbuf); - } - -#if 0 - if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) { - TRACE("[%s] free parser inbuf\n", __func__); - av_free(inbuf); - } -#endif - - qemu_mutex_unlock(&s->thread_mutex); - TRACE("Leave, %s\n", __func__); - - return ret; -} - -/* void av_parser_close(AVCodecParserContext *s) */ -void qemu_av_parser_close(SVCodecState *s, int ctx_index) -{ - AVCodecParserContext *parser_ctx; - - TRACE("Enter, %s\n", __func__); - qemu_mutex_lock(&s->thread_mutex); - - parser_ctx = s->codec_ctx[ctx_index].parser_ctx; - if (!parser_ctx) { - ERR("AVCodecParserContext is NULL\n"); - qemu_mutex_unlock(&s->thread_mutex); - return; - } - av_parser_close(parser_ctx); - - qemu_mutex_unlock(&s->thread_mutex); - TRACE("Leave, %s\n", __func__); -} - -int codec_operate(uint32_t api_index, uint32_t ctx_index, SVCodecState *s) -{ - int ret = -1; - - TRACE("[%s] context : %d\n", __func__, ctx_index); - switch (api_index) { - /* FFMPEG API */ - case EMUL_AV_REGISTER_ALL: - qemu_av_register_all(); - break; - case EMUL_AVCODEC_OPEN: - ret = qemu_avcodec_open(s); - break; - case EMUL_AVCODEC_CLOSE: - ret = qemu_avcodec_close(s, ctx_index); - qemu_av_free(s, ctx_index); - break; - case EMUL_AVCODEC_FLUSH_BUFFERS: - qemu_avcodec_flush_buffers(s, ctx_index); - break; - case EMUL_AVCODEC_DECODE_VIDEO: - case EMUL_AVCODEC_ENCODE_VIDEO: - case EMUL_AVCODEC_DECODE_AUDIO: - case EMUL_AVCODEC_ENCODE_AUDIO: - wake_codec_worker_thread(s); - break; - case EMUL_AV_PICTURE_COPY: - qemu_av_picture_copy(s, ctx_index); - break; - case EMUL_AV_PARSER_INIT: - qemu_av_parser_init(s, ctx_index); - break; - case EMUL_AV_PARSER_PARSE: - ret = qemu_av_parser_parse(s, ctx_index); - break; - case EMUL_AV_PARSER_CLOSE: - qemu_av_parser_close(s, ctx_index); - break; - default: - WARN("api index %d does not exist!.\n", api_index); - } - return ret; -} - -static uint32_t qemu_get_mmap_offset(SVCodecState *s) -{ - int index = 0; - - for (; index < AUDIO_CODEC_MEM_OFFSET_MAX; index++) { - if (s->audio_codec_offset[index] == 0) { - s->audio_codec_offset[index] = 1; - break; - } - } - TRACE("return mmap offset: %d\n", index); - - return index; -} - -/* - * Codec Device APIs - */ -uint64_t codec_read(void *opaque, hwaddr addr, unsigned size) -{ - SVCodecState *s = (SVCodecState *)opaque; - uint64_t ret = 0; - - switch (addr) { - case CODEC_CMD_GET_THREAD_STATE: - qemu_mutex_lock(&s->thread_mutex); - ret = s->codec_thread.state; - s->codec_thread.state = 0; - qemu_mutex_unlock(&s->thread_mutex); - TRACE("ret: %d, thread state: %d\n", ret, s->codec_thread.state); - qemu_irq_lower(s->dev.irq[0]); - break; - case CODEC_CMD_GET_VERSION: - ret = MARU_CODEC_VERSION; - TRACE("codec version: %d\n", ret); - break; - case CODEC_CMD_GET_DEVICE_MEM: - qemu_mutex_lock(&s->thread_mutex); - ret = s->device_mem_avail; - if (s->device_mem_avail != 1) { - s->device_mem_avail = 1; - } - qemu_mutex_unlock(&s->thread_mutex); - break; - case CODEC_CMD_GET_MMAP_OFFSET: - ret = qemu_get_mmap_offset(s); - TRACE("mem index: %d\n", ret); - break; - default: - ERR("no avaiable command for read. %d\n", addr); - } - - return ret; -} - -void codec_write(void *opaque, hwaddr addr, - uint64_t value, unsigned size) -{ - SVCodecState *s = (SVCodecState *)opaque; - - switch (addr) { - case CODEC_CMD_API_INDEX: - codec_operate(value, s->codec_param.ctx_index, s); - break; - case CODEC_CMD_CONTEXT_INDEX: - s->codec_param.ctx_index = value; - TRACE("Context Index: %d\n", s->codec_param.ctx_index); - break; - case CODEC_CMD_FILE_INDEX: - s->codec_param.file_index = value; - break; - case CODEC_CMD_DEVICE_MEM_OFFSET: - s->codec_param.mmap_offset = value; - TRACE("MMAP Offset: %d\n", s->codec_param.mmap_offset); - break; - case CODEC_CMD_RESET_CODEC_INFO: - qemu_reset_codec_info(s, value); - break; - case CODEC_CMD_SET_DEVICE_MEM: - qemu_mutex_lock(&s->thread_mutex); - s->device_mem_avail = value; - qemu_mutex_unlock(&s->thread_mutex); - break; - case CODEC_CMD_SET_MMAP_OFFSET: - s->codec_param.mem_index = value; - break; - default: - ERR("no avaiable command for write. %d\n", addr); - } -} - -static const MemoryRegionOps codec_mmio_ops = { - .read = codec_read, - .write = codec_write, - .endianness = DEVICE_LITTLE_ENDIAN, -}; - -static void codec_tx_bh(void *opaque) -{ - SVCodecState *s = (SVCodecState *)opaque; - - int ctx_index; - AVCodecContext *ctx; - - ctx_index = s->codec_param.ctx_index; - ctx = s->codec_ctx[ctx_index].avctx; - - TRACE("Enter, %s\n", __func__); - - /* raise irq as soon as a worker thread had finished a job*/ - if (s->codec_thread.state) { - TRACE("raise codec irq. state:%d, codec:%d\n", - s->codec_thread.state, ctx->codec_type); - qemu_irq_raise(s->dev.irq[0]); - } - - TRACE("Leave, %s\n", __func__); -} - -static int codec_initfn(PCIDevice *dev) -{ - SVCodecState *s = DO_UPCAST(SVCodecState, dev, dev); - uint8_t *pci_conf = s->dev.config; - - INFO("[%s] device init\n", __func__); - - memset(&s->codec_param, 0, sizeof(SVCodecParam)); - - qemu_mutex_init(&s->thread_mutex); - codec_thread_init(s); - s->tx_bh = qemu_bh_new(codec_tx_bh, s); - - pci_config_set_interrupt_pin(pci_conf, 1); - - memory_region_init_ram(&s->vram, OBJECT(s), "codec.ram", MARU_CODEC_MEM_SIZE); - s->vaddr = memory_region_get_ram_ptr(&s->vram); - - memory_region_init_io(&s->mmio, OBJECT(s), &codec_mmio_ops, s, - "codec-mmio", MARU_CODEC_REG_SIZE); - - pci_register_bar(&s->dev, 0, PCI_BASE_ADDRESS_MEM_PREFETCH, &s->vram); - pci_register_bar(&s->dev, 1, PCI_BASE_ADDRESS_SPACE_MEMORY, &s->mmio); - - return 0; -} - -static void codec_exitfn(PCIDevice *dev) -{ - SVCodecState *s = DO_UPCAST(SVCodecState, dev, dev); - INFO("[%s] device exit\n", __func__); - - qemu_bh_delete(s->tx_bh); - - memory_region_destroy(&s->vram); - memory_region_destroy(&s->mmio); -} - -int codec_init(PCIBus *bus) -{ - INFO("[%s] device create\n", __func__); - pci_create_simple(bus, -1, MARU_CODEC_DEV_NAME); - return 0; -} - -static void codec_class_init(ObjectClass *klass, void *data) -{ - DeviceClass *dc = DEVICE_CLASS(klass); - PCIDeviceClass *k = PCI_DEVICE_CLASS(klass); - - k->init = codec_initfn; - k->exit = codec_exitfn; - k->vendor_id = PCI_VENDOR_ID_TIZEN; - k->device_id = PCI_DEVICE_ID_VIRTUAL_CODEC; - k->class_id = PCI_CLASS_MULTIMEDIA_AUDIO; - dc->desc = "Virtual Codec device for Tizen emulator"; -} - -static TypeInfo codec_info = { - .name = MARU_CODEC_DEV_NAME, - .parent = TYPE_PCI_DEVICE, - .instance_size = sizeof(SVCodecState), - .class_init = codec_class_init, -}; - -static void codec_register_types(void) -{ - type_register_static(&codec_info); -} - -type_init(codec_register_types) diff --git a/tizen/src/hw/pci/maru_codec.h b/tizen/src/hw/pci/maru_codec.h deleted file mode 100644 index 999d232a63..0000000000 --- a/tizen/src/hw/pci/maru_codec.h +++ /dev/null @@ -1,174 +0,0 @@ -/* - * Virtual Codec device - * - * Copyright (c) 2011 - 2013 Samsung Electronics Co., Ltd All Rights Reserved - * - * Contact: - * Kitae Kim - * SeokYeon Hwang - * YeongKyoon Lee - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, - * MA 02110-1301, USA. - * - * Contributors: - * - S-Core Co., Ltd - * - */ - -#include -#include -#include "hw/hw.h" -#include "sysemu/kvm.h" -#include "hw/pci/pci.h" -#include "hw/pci/pci_ids.h" -#include "qemu/thread.h" -#include "debug_ch.h" -#include "maru_device_ids.h" - -#include - -#define CODEC_CONTEXT_MAX 1024 -#define VIDEO_CODEC_MEM_OFFSET_MAX 16 -#define AUDIO_CODEC_MEM_OFFSET_MAX 64 - -#define CODEC_MAX_THREAD 10 - -/* - * Codec Device Structures - */ -typedef struct _SVCodecParam { - uint32_t api_index; - uint32_t ctx_index; - uint32_t file_index; - uint32_t mem_index; - uint32_t mmap_offset; -} SVCodecParam; - -typedef struct _SVCodecContext { - AVCodecContext *avctx; - AVFrame *frame; - AVCodecParserContext *parser_ctx; - uint8_t *parser_buf; - uint8_t parser_use; - uint8_t avctx_use; - uint32_t file_index; - uint32_t mem_index; -} SVCodecContext; - -typedef struct _SVCodecThreadPool { - QemuThread *wrk_thread; - QemuMutex mutex; - QemuCond cond; - uint32_t state; - uint8_t isrunning; -} SVCodecThreadPool; - -typedef struct _SVCodecState { - PCIDevice dev; - - uint8_t *vaddr; - MemoryRegion vram; - MemoryRegion mmio; - - QEMUBH *tx_bh; - QemuMutex thread_mutex; - - SVCodecContext codec_ctx[CODEC_CONTEXT_MAX]; - SVCodecParam codec_param; - SVCodecThreadPool codec_thread; - uint8_t audio_codec_offset[AUDIO_CODEC_MEM_OFFSET_MAX]; - uint8_t device_mem_avail; - uint8_t isrunning; -} SVCodecState; - -enum codec_io_cmd { - CODEC_CMD_API_INDEX = 0x00, - CODEC_CMD_CONTEXT_INDEX = 0x04, - CODEC_CMD_FILE_INDEX = 0x08, - CODEC_CMD_DEVICE_MEM_OFFSET = 0x0c, - CODEC_CMD_GET_THREAD_STATE = 0x10, - CODEC_CMD_GET_VERSION = 0x14, - CODEC_CMD_GET_DEVICE_MEM = 0x18, - CODEC_CMD_SET_DEVICE_MEM = 0x1C, - CODEC_CMD_GET_MMAP_OFFSET = 0x20, - CODEC_CMD_SET_MMAP_OFFSET = 0x24, - CODEC_CMD_RESET_CODEC_INFO = 0x28, -}; - -enum { - EMUL_AV_REGISTER_ALL = 1, - EMUL_AVCODEC_OPEN, - EMUL_AVCODEC_CLOSE, - EMUL_AVCODEC_FLUSH_BUFFERS, - EMUL_AVCODEC_DECODE_VIDEO, - EMUL_AVCODEC_ENCODE_VIDEO, - EMUL_AVCODEC_DECODE_AUDIO, - EMUL_AVCODEC_ENCODE_AUDIO, - EMUL_AV_PICTURE_COPY, - EMUL_AV_PARSER_INIT, - EMUL_AV_PARSER_PARSE, - EMUL_AV_PARSER_CLOSE, -}; - - -/* - * Codec Thread Functions - */ -void codec_thread_init(SVCodecState *s); -void codec_thread_exit(SVCodecState *s); -void *codec_worker_thread(void *opaque); -void wake_codec_worker_thread(SVCodecState *s); -int decode_codec(SVCodecState *s); -int encode_codec(SVCodecState *s); - -/* - * Codec Device Functions - */ -int codec_init(PCIBus *bus); -uint64_t codec_read(void *opaque, hwaddr addr, - unsigned size); -void codec_write(void *opaque, hwaddr addr, - uint64_t value, unsigned size); -int codec_operate(uint32_t api_index, uint32_t ctx_index, - SVCodecState *state); - -/* - * Codec Helper Functions - */ -void qemu_parser_init(SVCodecState *s, int ctx_index); -void qemu_codec_close(SVCodecState *s, uint32_t value); -void qemu_get_codec_ver(SVCodecState *s); -void qemu_reset_codec_info(SVCodecState *s, uint32_t value); - -/* - * FFMPEG Functions - */ -void qemu_av_register_all(void); -int qemu_avcodec_open(SVCodecState *s); -int qemu_avcodec_close(SVCodecState *s, int ctx_index); -int qemu_avcodec_alloc_context(SVCodecState *s); -void qemu_avcodec_flush_buffers(SVCodecState *s, int ctx_index); -int qemu_avcodec_decode_video(SVCodecState *s, int ctx_index); -int qemu_avcodec_encode_video(SVCodecState *s, int ctx_index); -int qemu_avcodec_decode_audio(SVCodecState *s, int ctx_index); -int qemu_avcodec_encode_audio(SVCodecState *s, int ctx_index); -void qemu_av_picture_copy(SVCodecState *s, int ctx_index); -void qemu_av_parser_init(SVCodecState *s, int ctx_index); -int qemu_av_parser_parse(SVCodecState *s, int ctx_index); -void qemu_av_parser_close(SVCodecState *s, int ctx_index); -int qemu_avcodec_get_buffer(AVCodecContext *context, AVFrame *picture); -void qemu_avcodec_release_buffer(AVCodecContext *context, AVFrame *picture); -void qemu_av_free(SVCodecState *s, int ctx_index);