예제 #1
0
static s32 vdecoder_close(cedarv_decoder_t* p)
{
    video_decoder_t* decoder;

    if(p == NULL)
        return CEDARV_RESULT_ERR_INVALID_PARAM;

    decoder = (video_decoder_t*)p;

    libve_reset(0, decoder->ve);

    if(decoder->stream_info.init_data != NULL)
    {
        mem_free(decoder->stream_info.init_data);
        decoder->stream_info.init_data = NULL;
    }

    if(decoder->ve != NULL)
    {
        libve_close(0, decoder->ve);
        decoder->ve = NULL;
        decoder->fbm = NULL;
    }

    if(decoder->vbv != NULL)
    {
        vbv_release(decoder->vbv);
        decoder->vbv = NULL;
    }

    return CEDARV_RESULT_OK;
}
예제 #2
0
cedarx_result_e libcedarx_decoder_decode_stream(int force)
{
    vresult_e res;
    cedarx_result_e result;
    cedarx_decoder_t* decoder = cedarx_decoder;
    
    if ((!decoder) || (!decoder->ve) || (!decoder->vbv)) 
      return CEDARX_RESULT_NO_INIT;
    
    if (!force) {
        if (vbv_check_stream_frame(decoder->vbv) < 0)
            return CEDARX_RESULT_VBV_BUFFER_EMPTY;
    }
    
    res = libve_decode(0, 0, 0, decoder->ve);
    switch (res) {
      case VRESULT_OK:  
      case VRESULT_FRAME_DECODED:  
      case VRESULT_KEYFRAME_DECODED:  
          result = CEDARX_RESULT_OK;
          break;
      case VRESULT_NO_FRAME_BUFFER:  
          printf("Warning: There are not more framebuffer!\n");
          result = CEDARX_RESULT_NO_FRAME_BUFFER;
          break;
      case VRESULT_NO_BITSTREAM:  
          printf("Warning: There are not more bitstream!\n");
          result = CEDARX_RESULT_VBV_BUFFER_EMPTY;
          break;
      default:
          printf("Error: Decode failed(%d), try to reset decoder!\n", res);
          libve_reset(0, decoder->ve);
          return CEDARX_RESULT_VE_FAILED;     
    }
    
    return result;
}
예제 #3
0
static s32 vdecoder_io_ctrl(cedarv_decoder_t* p, u32 cmd, u32 param)
{
    video_decoder_t* decoder;

    if(p == NULL)
        return CEDARV_RESULT_ERR_INVALID_PARAM;

    decoder = (video_decoder_t*)p;

    if(p == NULL)
        return CEDARV_RESULT_ERR_INVALID_PARAM;

    switch(cmd)
    {
        case CEDARV_COMMAND_PLAY:
        {
            if(decoder->status != CEDARV_STATUS_PLAY && decoder->status != CEDARV_STATUS_STOP)
                decoder->mode_switched = 1;

            decoder->status = CEDARV_STATUS_PLAY;

            return CEDARV_RESULT_OK;
        }

        case CEDARV_COMMAND_FORWARD:
        {
            if(decoder->status != CEDARV_STATUS_PLAY)
                return CEDARV_RESULT_ERR_FAIL;

            decoder->status = CEDARV_STATUS_FORWARD;
            decoder->mode_switched = 1;

            return CEDARV_RESULT_OK;
        }

        case CEDARV_COMMAND_BACKWARD:
        {
            if(decoder->status != CEDARV_STATUS_PLAY)
                return CEDARV_RESULT_ERR_FAIL;

            decoder->status = CEDARV_STATUS_BACKWARD;
            decoder->mode_switched = 1;

            return CEDARV_RESULT_OK;
        }

        case CEDARV_COMMAND_STOP:
        {
            if(decoder->status != CEDARV_STATUS_PLAY && decoder->status != CEDARV_STATUS_FORWARD && decoder->status != CEDARV_STATUS_BACKWARD)
                return CEDARV_RESULT_ERR_FAIL;

            decoder->status = CEDARV_STATUS_STOP;
            decoder->mode_switched = 1;

            return CEDARV_RESULT_OK;
        }

        case CEDARV_COMMAND_ROTATE:
        {
            if(param > 5)
                return CEDARV_RESULT_ERR_FAIL;

            decoder->config_info.rotate_angle  = param;
            if(param != 0)
                decoder->config_info.rotate_enable = 1;

            return CEDARV_RESULT_OK;
        }

        case CEDARV_COMMAND_JUMP:
        {
        	libve_reset(0, decoder->ve);

            vbv_reset(decoder->vbv);
            if(p->free_vbs_buffer_sem != NULL)
                p->free_vbs_buffer_sem(p->cedarx_cookie);

            if(decoder->fbm != NULL)
            {
                if(decoder->display_already_begin)
                    fbm_reset(decoder->last_frame_index, decoder->fbm);
                else
                    fbm_reset(0xff, decoder->fbm);

                if(p->release_frame_buffer_sem != NULL)
                    p->release_frame_buffer_sem(p->cedarx_cookie);
            }

        	return CEDARV_RESULT_OK;
        }

//        case VDEC_QUERY_VBSBUFFER_USAGE_CMD:
//        {
//            s32 usage1, usage2;
//
//            if(p->vbv != NULL && vbv_get_buffer_size(p->vbv) != 0)
//            {
//                usage1 = vbv_get_valid_data_size(p->vbv) * 100 / vbv_get_buffer_size(p->vbv);
//                usage2 = vbv_get_valid_frame_num(p->vbv) * 100 / vbv_get_max_stream_frame_num(p->vbv);
//
//                return (usage1 > usage2) ? usage1 : usage2;
//            }
//
//            return 0;
//        }

        case CEDARV_COMMAND_SET_TOTALMEMSIZE:
        {
            decoder->remainMemorySize = param;
            return CEDARV_RESULT_OK;
        }


		case CEDARV_COMMAND_PREVIEW_MODE:
		{
			decoder->status = CEDARV_STATUS_PREVIEW;
			return CEDARV_RESULT_OK;
		}

        default:
            return CEDARV_RESULT_ERR_FAIL;
    }
}
예제 #4
0
static s32 vdecoder_decode(cedarv_decoder_t* p)
{
    vresult_e        vresult;

#if (DECODE_FREE_RUN == 0)
    u64              video_time;
#endif

    video_decoder_t* decoder;

    if(p == NULL)
        return CEDARV_RESULT_ERR_INVALID_PARAM;

    decoder = (video_decoder_t*)p;

    if(decoder->mode_switched)
    {
    	libve_reset(0, decoder->ve);

        vbv_reset(decoder->vbv);
        if(p->free_vbs_buffer_sem != NULL)
            p->free_vbs_buffer_sem(p->cedarx_cookie);

        if(decoder->fbm != NULL)
        {
			fbm_flush(decoder->fbm);
            if(p->release_frame_buffer_sem != NULL)
                p->release_frame_buffer_sem(p->cedarx_cookie);
        }

    	decoder->mode_switched = 0;

    	return CEDARV_RESULT_NO_BITSTREAM;
    }

    if(decoder->status == CEDARV_STATUS_BACKWARD || decoder->status == CEDARV_STATUS_FORWARD)
    {
    	vresult = libve_decode(1, 0, 0, decoder->ve);
    }
    else
    {
    	if(decoder->stream_info.format == STREAM_FORMAT_H264 && decoder->display_already_begin == 0)
    	{
    		//* for H264, when decoding the first data unit containing PPS, we have to promise
    		//* there is more than one bitstream frame for decoding.
    		//* that is because the decoder uses the start code of the second bitstream frame
    		//* to judge PPS end.
    		if(vbv_get_stream_num(decoder->vbv) < 2)
    			return CEDARV_RESULT_NO_BITSTREAM;
    	}

    	if(decoder->status == CEDARV_STATUS_PREVIEW)
    	{
    		vresult = libve_decode(1, 0, 0, decoder->ve);
    	}
    	else
    	{
#if (DECODE_FREE_RUN == 0)
    	video_time = esMODS_MIoctrl(vdrv_com->avsync, DRV_AVS_CMD_GET_VID_TIME, DRV_AVS_TIME_TOTAL, 0);
    	video_time *= 1000;
    	vresult = libve_decode(0, 1, video_time, decoder->ve);
#else
    	vresult = libve_decode(0, 0, 0, decoder->ve);
#endif
    	}
    }

    if(vresult == VRESULT_OK)
    {
        return CEDARV_RESULT_OK;
    }
    else if(vresult == VRESULT_FRAME_DECODED)
    {
    	return CEDARV_RESULT_FRAME_DECODED;
    }
    else if(vresult == VRESULT_KEYFRAME_DECODED)
    {
    	if(decoder->status == CEDARV_STATUS_BACKWARD || decoder->status == CEDARV_STATUS_FORWARD || decoder->status == CEDARV_STATUS_PREVIEW)
    	{
    		libve_reset(1, decoder->ve);
    	}
        return CEDARV_RESULT_KEYFRAME_DECODED;
    }
    else if(vresult == VRESULT_NO_FRAME_BUFFER)
    {
        return CEDARV_RESULT_NO_FRAME_BUFFER;
    }
    else if(vresult == VRESULT_NO_BITSTREAM)
    {
        return CEDARV_RESULT_NO_BITSTREAM;
    }
    else if(vresult == VRESULT_ERR_NO_MEMORY)
    {
        return CEDARV_RESULT_ERR_NO_MEMORY;
    }
    else if( vresult == VRESULT_ERR_UNSUPPORTED)
    {
        return CEDARV_RESULT_ERR_UNSUPPORTED;
    }
    else if(vresult == VRESULT_ERR_LIBRARY_NOT_OPEN)
    {
        return CEDARV_RESULT_ERR_FAIL;
    }
    else
    {
        return CEDARV_RESULT_OK;
    }
}
예제 #5
0
파일: libcedarx.c 프로젝트: ssvb/libcedarx
cedarx_result_e libcedarx_decoder_open(cedarx_info_t* info)
{
  cedarx_result_e result;
  vconfig_t config;
  vstream_info_t stream_info;
  cedarx_decoder_t* decoder;
  
  if (!info) 
    return CEDARX_RESULT_INVALID_ARGS;

  if ((info->width > MAX_SUPPORTED_VIDEO_WIDTH) || \
        (info->height > MAX_SUPPORTED_VIDEO_HEIGHT))
    return CEDARX_RESULT_INVALID_ARGS;
    
  decoder = (cedarx_decoder_t*)mem_alloc(sizeof(cedarx_decoder_t));
  if (!decoder)
    return CEDARX_RESULT_NO_ENOUGH_MEMORY;

  mem_set(decoder, 0, sizeof(cedarx_decoder_t));
  cedarx_decoder = decoder;
  
  result = ve_init();
  if (CEDARX_RESULT_OK != result) 
    goto failed3;
          
  mem_set(&config, 0, sizeof(vconfig_t));
  mem_set(&stream_info, 0, sizeof(vstream_info_t));
  
  config.max_video_width  = MAX_SUPPORTED_VIDEO_WIDTH;
  config.max_video_height = MAX_SUPPORTED_VIDEO_HEIGHT;
  config.max_output_width = MAX_SUPPORTED_OUTPUT_WIDTH; 
  config.max_output_height = MAX_SUPPORTED_OUTPUT_HEIGHT;

  switch (info->stream)
  {
    case CEDARX_STREAM_FORMAT_MPEG1:
      stream_info.format = STREAM_FORMAT_MPEG2;
      stream_info.sub_format = MPEG2_SUB_FORMAT_MPEG1;
      break;    
    case CEDARX_STREAM_FORMAT_MPEG2:
      stream_info.format = STREAM_FORMAT_MPEG2;
      stream_info.sub_format = MPEG2_SUB_FORMAT_MPEG2;
      break;    
    case CEDARX_STREAM_FORMAT_XVID:
      stream_info.format = STREAM_FORMAT_MPEG4;
      stream_info.sub_format = MPEG4_SUB_FORMAT_XVID;
      break;    
    case CEDARX_STREAM_FORMAT_DIVX1:
      stream_info.format = STREAM_FORMAT_MPEG4;
      stream_info.sub_format = MPEG4_SUB_FORMAT_DIVX1;
      break;    
    case CEDARX_STREAM_FORMAT_DIVX2:
      stream_info.format = STREAM_FORMAT_MPEG4;
      stream_info.sub_format = MPEG4_SUB_FORMAT_DIVX2;
      break;    
    case CEDARX_STREAM_FORMAT_DIVX3:
      stream_info.format = STREAM_FORMAT_MPEG4;
      stream_info.sub_format = MPEG4_SUB_FORMAT_DIVX3;
      break;    
    case CEDARX_STREAM_FORMAT_DIVX4:
      stream_info.format = STREAM_FORMAT_MPEG4;
      stream_info.sub_format = MPEG4_SUB_FORMAT_DIVX4;
      break;    
    case CEDARX_STREAM_FORMAT_DIVX5:
      stream_info.format = STREAM_FORMAT_MPEG4;
      stream_info.sub_format = MPEG4_SUB_FORMAT_DIVX5;
      break;    
    case CEDARX_STREAM_FORMAT_H263:
      stream_info.format = STREAM_FORMAT_MPEG4;
      stream_info.sub_format = MPEG4_SUB_FORMAT_H263;
      break;    
    case CEDARX_STREAM_FORMAT_SORENSSON_H263:
      stream_info.format = STREAM_FORMAT_MPEG4;
      stream_info.sub_format = MPEG4_SUB_FORMAT_SORENSSON_H263;
      break;    
    case CEDARX_STREAM_FORMAT_WMV1:
      stream_info.format = STREAM_FORMAT_MPEG4;
      stream_info.sub_format = MPEG4_SUB_FORMAT_WMV1;
      break;    
    case CEDARX_STREAM_FORMAT_WMV2:
      stream_info.format = STREAM_FORMAT_MPEG4;
      stream_info.sub_format = MPEG4_SUB_FORMAT_WMV2;
      break;    
    case CEDARX_STREAM_FORMAT_VP6:
      stream_info.format = STREAM_FORMAT_MPEG4;
      stream_info.sub_format = MPEG4_SUB_FORMAT_VP6;
      break;    
    case CEDARX_STREAM_FORMAT_REALVIDEO:
      stream_info.format = STREAM_FORMAT_REALVIDEO;
      stream_info.sub_format = STREAM_SUB_FORMAT_UNKNOW;
      break;    
    case CEDARX_STREAM_FORMAT_H264:
      stream_info.format = STREAM_FORMAT_H264;
      stream_info.sub_format = STREAM_SUB_FORMAT_UNKNOW;
      stream_info.is_pts_correct = 1;
      decoder->greedy = 1;
      break;    
    case CEDARX_STREAM_FORMAT_VC1:
      stream_info.format = STREAM_FORMAT_VC1;
      stream_info.sub_format = STREAM_SUB_FORMAT_UNKNOW;
      break;    
    case CEDARX_STREAM_FORMAT_AVS:
      stream_info.format = STREAM_FORMAT_AVS;
      stream_info.sub_format = STREAM_SUB_FORMAT_UNKNOW;
      break;    
    case CEDARX_STREAM_FORMAT_MJPEG:
      stream_info.format = STREAM_FORMAT_MJPEG;
      stream_info.sub_format = STREAM_SUB_FORMAT_UNKNOW;
      break;    
    case CEDARX_STREAM_FORMAT_VP8:
      stream_info.format = STREAM_FORMAT_VP8;
      stream_info.sub_format = STREAM_SUB_FORMAT_UNKNOW;
      break;
    default:
      result = CEDARX_RESULT_INVALID_ARGS;
      goto failed2;
  } 

  switch (info->container)
  {
    case CEDARX_CONTAINER_FORMAT_AVI:
      stream_info.container_format = CONTAINER_FORMAT_AVI;
      break;
    case CEDARX_CONTAINER_FORMAT_ASF:
      stream_info.container_format = CONTAINER_FORMAT_ASF;
      break;
    case CEDARX_CONTAINER_FORMAT_DAT:
      stream_info.container_format = CONTAINER_FORMAT_DAT;
      break;
    case CEDARX_CONTAINER_FORMAT_FLV:
      stream_info.container_format = CONTAINER_FORMAT_FLV;
      break;
    case CEDARX_CONTAINER_FORMAT_MKV:
      stream_info.container_format = CONTAINER_FORMAT_MKV;
      break;
    case CEDARX_CONTAINER_FORMAT_MOV:
      stream_info.container_format = CONTAINER_FORMAT_MOV;
      break;
    case CEDARX_CONTAINER_FORMAT_MPG:
      stream_info.container_format = CONTAINER_FORMAT_MPG;
      break;
    case CEDARX_CONTAINER_FORMAT_PMP:
      stream_info.container_format = CONTAINER_FORMAT_PMP;
      break;
    case CEDARX_CONTAINER_FORMAT_RM:
      stream_info.container_format = CONTAINER_FORMAT_RM;
      break;
    case CEDARX_CONTAINER_FORMAT_TS:
      stream_info.container_format = CONTAINER_FORMAT_TS;
      stream_info.is_pts_correct = 1;
      break;
    case CEDARX_CONTAINER_FORMAT_VOB:
      stream_info.container_format = CONTAINER_FORMAT_VOB;
      break;
    case CEDARX_CONTAINER_FORMAT_WEBM:
      stream_info.container_format = CONTAINER_FORMAT_WEBM;
      break;
    case CEDARX_CONTAINER_FORMAT_OGM:
      stream_info.container_format = CONTAINER_FORMAT_OGM;
      break;
    default:
      stream_info.container_format = CONTAINER_FORMAT_UNKNOW;
      break;
  }

  stream_info.video_width = info->width;
  stream_info.video_height = info->height;
  stream_info.frame_rate = info->frame_rate;
  stream_info.frame_duration = info->frame_duration;
  stream_info.aspec_ratio = 1000;

  if (info->data && (info->data_size > 0)) {
    decoder->init_data = mem_alloc(info->data_size);
    if (!decoder->init_data) {
        result = CEDARX_RESULT_NO_ENOUGH_MEMORY;
        goto failed2;
    }
    mem_cpy(decoder->init_data, info->data, info->data_size);
    stream_info.init_data = decoder->init_data;
    stream_info.init_data_len = info->data_size;
  } else {
    stream_info.init_data_len = 0;
    stream_info.init_data = NULL;
  }
  stream_info._3d_mode = _3D_MODE_NONE;

  mem_init(decoder->fd);
  ve_request();

  if (info->request_buffer)
    decoder->request_buffer = info->request_buffer;
  if (info->update_buffer)
    decoder->update_buffer = info->update_buffer;
  if (info->release_buffer)
    decoder->release_buffer = info->release_buffer;
  if (info->lock_buffer)
    decoder->lock_buffer = info->lock_buffer;
  if (info->unlock_buffer)
    decoder->unlock_buffer = info->unlock_buffer;
 
  decoder->sys = info->sys;
  decoder->ve = libve_open(&config, &stream_info, decoder);
  if (!decoder->ve) {
    result = CEDARX_RESULT_VE_FAILED;
    goto failed1;
  }
  
  libve_reset(0, decoder->ve);  
  decoder->vbv = vbv_init();
  if (!decoder->vbv) {
    result = CEDARX_RESULT_NO_ENOUGH_MEMORY;
    goto failed0;
  }
    
  libve_set_vbv(decoder->vbv, decoder->ve);
  return CEDARX_RESULT_OK; 

failed0:
  libve_close(0, decoder->ve);  
failed1:
  ve_release();
  mem_exit();
  if (decoder->init_data)
    mem_free(decoder->init_data);
failed2:
  ve_exit();
failed3:
  mem_free(decoder); 
  cedarx_decoder = NULL;
  return result;    
}