|
amcodecMy Project
|
codec_ctrl.c
Go to the documentation of this file.
00001 00008 /* Copyright (C) 2007-2011, Amlogic Inc. 00009 * All right reserved 00010 * 00011 */ 00012 #include <stdio.h> 00013 #include <stdio.h> 00014 #include <string.h> 00015 #include <sys/types.h> 00016 #include <sys/stat.h> 00017 #include <sys/poll.h> 00018 #include <errno.h> 00019 #include <sys/ioctl.h> 00020 #include <fcntl.h> 00021 #include <codec_error.h> 00022 #include <codec_type.h> 00023 #include <codec.h> 00024 #include <audio_priv.h> 00025 #include "codec_h_ctrl.h" 00026 #include <adec-external-ctrl.h> 00027 00028 #define SUBTITLE_EVENT 00029 #define TS_PACKET_SIZE 188 00030 #define DEMUX_PLAYER_SOURCE 1 00031 00032 /* --------------------------------------------------------------------------*/ 00041 /* --------------------------------------------------------------------------*/ 00042 static int codec_set_demux_source(codec_para_t *pcodec, int source) 00043 { 00044 int ret = 0; 00045 00046 ret = codec_h_control(pcodec->handle, AMSTREAM_IOC_SET_DEMUX, (unsigned long)source); 00047 if (ret < 0) { 00048 return ret; 00049 } 00050 return ret; 00051 } 00052 00053 /* --------------------------------------------------------------------------*/ 00061 /* --------------------------------------------------------------------------*/ 00062 static int codec_change_buf_size(codec_para_t *pcodec) 00063 { 00064 int r; 00065 if (pcodec->abuf_size > 0) { 00066 r = codec_h_control(pcodec->handle, AMSTREAM_IOC_AB_SIZE, pcodec->abuf_size); 00067 if (r < 0) { 00068 return system_error_to_codec_error(r); 00069 } 00070 } 00071 if (pcodec->vbuf_size > 0) { 00072 r = codec_h_control(pcodec->handle, AMSTREAM_IOC_VB_SIZE, pcodec->vbuf_size); 00073 if (r < 0) { 00074 return system_error_to_codec_error(r); 00075 } 00076 } 00077 return CODEC_ERROR_NONE; 00078 } 00079 /* --------------------------------------------------------------------------*/ 00087 /* --------------------------------------------------------------------------*/ 00088 static int set_video_format(codec_para_t *pcodec) 00089 { 00090 int format = pcodec->video_type; 00091 int r; 00092 00093 if (format < 0 || format > VFORMAT_MAX) { 00094 return -CODEC_ERROR_VIDEO_TYPE_UNKNOW; 00095 } 00096 00097 r = codec_h_control(pcodec->handle, AMSTREAM_IOC_VFORMAT, format); 00098 if (pcodec->video_pid >= 0) { 00099 r = codec_h_control(pcodec->handle, AMSTREAM_IOC_VID, pcodec->video_pid); 00100 if (r < 0) { 00101 return system_error_to_codec_error(r); 00102 } 00103 } 00104 if (r < 0) { 00105 return system_error_to_codec_error(r); 00106 } 00107 return 0; 00108 } 00109 00110 /* --------------------------------------------------------------------------*/ 00118 /* --------------------------------------------------------------------------*/ 00119 static int set_video_codec_info(codec_para_t *pcodec) 00120 { 00121 dec_sysinfo_t am_sysinfo = pcodec->am_sysinfo; 00122 int r; 00123 00124 r = codec_h_control(pcodec->handle, AMSTREAM_IOC_SYSINFO, (unsigned long)&am_sysinfo); 00125 if (r < 0) { 00126 return system_error_to_codec_error(r); 00127 } 00128 return 0; 00129 } 00130 /* --------------------------------------------------------------------------*/ 00138 /* --------------------------------------------------------------------------*/ 00139 static int set_audio_format(codec_para_t *pcodec) 00140 { 00141 int format = pcodec->audio_type; 00142 int r; 00143 int codec_r; 00144 00145 if (format < 0 || format > AFORMAT_MAX) { 00146 return -CODEC_ERROR_AUDIO_TYPE_UNKNOW; 00147 } 00148 00149 r = codec_h_control(pcodec->handle, AMSTREAM_IOC_AFORMAT, format); 00150 if (r < 0) { 00151 codec_r = system_error_to_codec_error(r); 00152 print_error_msg(codec_r, errno, __FUNCTION__, __LINE__); 00153 return codec_r; 00154 } 00155 if (pcodec->audio_pid >= 0) { 00156 r = codec_h_control(pcodec->handle, AMSTREAM_IOC_AID, pcodec->audio_pid); 00157 if (r < 0) { 00158 codec_r = system_error_to_codec_error(r); 00159 print_error_msg(codec_r, errno, __FUNCTION__, __LINE__); 00160 return codec_r; 00161 } 00162 } 00163 if (pcodec->audio_samplerate > 0) { 00164 r = codec_h_control(pcodec->handle, AMSTREAM_IOC_SAMPLERATE, pcodec->audio_samplerate); 00165 if (r < 0) { 00166 codec_r = system_error_to_codec_error(r); 00167 print_error_msg(codec_r, errno, __FUNCTION__, __LINE__); 00168 return codec_r; 00169 } 00170 } 00171 if (pcodec->audio_channels > 0) { 00172 r = codec_h_control(pcodec->handle, AMSTREAM_IOC_ACHANNEL, pcodec->audio_channels); 00173 if (r < 0) { 00174 codec_r = system_error_to_codec_error(r); 00175 print_error_msg(codec_r, errno, __FUNCTION__, __LINE__); 00176 return codec_r; 00177 } 00178 } 00179 return 0; 00180 } 00181 00182 /* --------------------------------------------------------------------------*/ 00190 /* --------------------------------------------------------------------------*/ 00191 static int set_audio_info(codec_para_t *pcodec) 00192 { 00193 int r; 00194 int codec_r; 00195 audio_info_t *audio_info = &pcodec->audio_info; 00196 CODEC_PRINT("set_audio_info\n"); 00197 r = codec_h_control(pcodec->handle, AMSTREAM_IOC_AUDIO_INFO, (unsigned long)audio_info); 00198 if (r < 0) { 00199 codec_r = system_error_to_codec_error(r); 00200 print_error_msg(codec_r, errno, __FUNCTION__, __LINE__); 00201 return codec_r; 00202 } 00203 return 0; 00204 } 00205 00206 /* --------------------------------------------------------------------------*/ 00214 /* --------------------------------------------------------------------------*/ 00215 static int set_sub_format(codec_para_t *pcodec) 00216 { 00217 int r; 00218 00219 if (pcodec->sub_pid >= 0) { 00220 r = codec_h_control(pcodec->handle, AMSTREAM_IOC_SID, pcodec->sub_pid); 00221 if (r < 0) { 00222 return system_error_to_codec_error(r); 00223 } 00224 00225 r = codec_h_control(pcodec->handle, AMSTREAM_IOC_SUB_TYPE, pcodec->sub_type); 00226 if (r < 0) { 00227 return system_error_to_codec_error(r); 00228 } 00229 } 00230 00231 return 0; 00232 } 00233 00234 /* --------------------------------------------------------------------------*/ 00242 /* --------------------------------------------------------------------------*/ 00243 static int set_ts_skip_byte(codec_para_t *pcodec) 00244 { 00245 int r, skip_byte; 00246 00247 skip_byte = pcodec->packet_size - TS_PACKET_SIZE; 00248 00249 if (skip_byte < 0) { 00250 skip_byte = 0; 00251 } 00252 00253 r = codec_h_control(pcodec->handle, AMSTREAM_IOC_TS_SKIPBYTE, skip_byte); 00254 if (r < 0) { 00255 return system_error_to_codec_error(r); 00256 } 00257 00258 return 0; 00259 } 00260 00261 /* --------------------------------------------------------------------------*/ 00269 /* --------------------------------------------------------------------------*/ 00270 static inline int codec_video_es_init(codec_para_t *pcodec) 00271 { 00272 CODEC_HANDLE handle; 00273 int r; 00274 int codec_r; 00275 int flags = O_WRONLY; 00276 if (!pcodec->has_video) { 00277 return CODEC_ERROR_NONE; 00278 } 00279 00280 flags |= pcodec->noblock ? O_NONBLOCK : 0; 00281 00282 if (pcodec->video_type == VFORMAT_HEVC) { 00283 handle = codec_h_open(CODEC_VIDEO_HEVC_DEVICE, flags); 00284 } else { 00285 handle = codec_h_open(CODEC_VIDEO_ES_DEVICE, flags); 00286 } 00287 if (handle < 0) { 00288 codec_r = system_error_to_codec_error(handle); 00289 print_error_msg(codec_r, errno, __FUNCTION__, __LINE__); 00290 return CODEC_OPEN_HANDLE_FAILED; 00291 } 00292 pcodec->handle = handle; 00293 r = set_video_format(pcodec); 00294 if (r < 0) { 00295 codec_h_close(handle); 00296 codec_r = system_error_to_codec_error(r); 00297 print_error_msg(codec_r, errno, __FUNCTION__, __LINE__); 00298 return codec_r; 00299 } 00300 r = set_video_codec_info(pcodec); 00301 if (r < 0) { 00302 codec_h_close(handle); 00303 codec_r = system_error_to_codec_error(r); 00304 print_error_msg(codec_r, errno, __FUNCTION__, __LINE__); 00305 return codec_r; 00306 } 00307 return CODEC_ERROR_NONE; 00308 } 00309 00310 00311 /* --------------------------------------------------------------------------*/ 00319 /* --------------------------------------------------------------------------*/ 00320 static inline int codec_audio_es_init(codec_para_t *pcodec) 00321 { 00322 CODEC_HANDLE handle; 00323 int r; 00324 int flags = O_WRONLY; 00325 int codec_r; 00326 if (!pcodec->has_audio) { 00327 return CODEC_ERROR_NONE; 00328 } 00329 00330 flags |= pcodec->noblock ? O_NONBLOCK : 0; 00331 handle = codec_h_open(CODEC_AUDIO_ES_DEVICE, flags); 00332 if (handle < 0) { 00333 codec_r = system_error_to_codec_error(handle); 00334 print_error_msg(codec_r, errno, __FUNCTION__, __LINE__); 00335 return CODEC_OPEN_HANDLE_FAILED; 00336 } 00337 pcodec->handle = handle; 00338 r = set_audio_format(pcodec); 00339 if (r < 0) { 00340 codec_h_close(handle); 00341 codec_r = system_error_to_codec_error(r); 00342 print_error_msg(codec_r, errno, __FUNCTION__, __LINE__); 00343 return codec_r; 00344 } 00345 00346 /*if ((pcodec->audio_type == AFORMAT_ADPCM) || (pcodec->audio_type == AFORMAT_WMAPRO) || (pcodec->audio_type == AFORMAT_WMA) || (pcodec->audio_type == AFORMAT_PCM_S16BE) 00347 || (pcodec->audio_type == AFORMAT_PCM_S16LE) || (pcodec->audio_type == AFORMAT_PCM_U8)||(pcodec->audio_type == AFORMAT_AMR)) {*/ 00348 if(IS_AUIDO_NEED_EXT_INFO(pcodec->audio_type)){ 00349 r = set_audio_info(pcodec); 00350 if (r < 0) { 00351 codec_h_close(handle); 00352 codec_r = system_error_to_codec_error(r); 00353 print_error_msg(codec_r, errno, __FUNCTION__, __LINE__); 00354 return codec_r; 00355 } 00356 } 00357 00358 return CODEC_ERROR_NONE; 00359 } 00360 00361 /* --------------------------------------------------------------------------*/ 00369 /* --------------------------------------------------------------------------*/ 00370 static inline int codec_sub_es_init(codec_para_t *pcodec) 00371 { 00372 #ifdef SUBTITLE_EVENT 00373 int r, codec_r; 00374 00375 if (pcodec->has_sub) { 00376 r = codec_init_sub(pcodec); 00377 if (r < 0) { 00378 codec_r = system_error_to_codec_error(r); 00379 print_error_msg(codec_r, errno, __FUNCTION__, __LINE__); 00380 return CODEC_OPEN_HANDLE_FAILED; 00381 } 00382 pcodec->handle = pcodec->sub_handle; 00383 00384 pcodec->sub_pid = 0xffff; // for es, sub id is identified for es parser 00385 r = set_sub_format(pcodec); 00386 if (r < 0) { 00387 codec_r = system_error_to_codec_error(r); 00388 print_error_msg(codec_r, errno, __FUNCTION__, __LINE__); 00389 return codec_r; 00390 } 00391 00392 } 00393 00394 #endif 00395 00396 return CODEC_ERROR_NONE; 00397 } 00398 00399 /* --------------------------------------------------------------------------*/ 00407 /* --------------------------------------------------------------------------*/ 00408 static inline int codec_ps_init(codec_para_t *pcodec) 00409 { 00410 CODEC_HANDLE handle; 00411 int r; 00412 int flags = O_WRONLY; 00413 int codec_r; 00414 if (!((pcodec->has_video && IS_VALID_PID(pcodec->video_pid)) || 00415 (pcodec->has_audio && IS_VALID_PID(pcodec->audio_pid)))) { 00416 return -CODEC_ERROR_PARAMETER; 00417 } 00418 00419 flags |= pcodec->noblock ? O_NONBLOCK : 0; 00420 handle = codec_h_open(CODEC_PS_DEVICE, flags); 00421 if (handle < 0) { 00422 codec_r = system_error_to_codec_error(handle); 00423 print_error_msg(codec_r, errno, __FUNCTION__, __LINE__); 00424 return CODEC_OPEN_HANDLE_FAILED; 00425 } 00426 pcodec->handle = handle; 00427 if (pcodec->has_video) { 00428 r = set_video_format(pcodec); 00429 if (r < 0) { 00430 goto error1; 00431 } 00432 if ((pcodec->video_type == VFORMAT_H264) 00433 || (pcodec->video_type == VFORMAT_VC1)){ 00434 r = set_video_codec_info(pcodec); 00435 if (r < 0) { 00436 /*codec_h_close(handle); 00437 codec_r = system_error_to_codec_error(r); 00438 print_error_msg(codec_r, errno, __FUNCTION__, __LINE__); 00439 return codec_r; */ 00440 goto error1; 00441 } 00442 } 00443 } 00444 if (pcodec->has_audio) { 00445 r = set_audio_format(pcodec); 00446 if (r < 0) { 00447 goto error1; 00448 } 00449 00450 /*if ((pcodec->audio_type == AFORMAT_ADPCM) || (pcodec->audio_type == AFORMAT_WMA) || (pcodec->audio_type == AFORMAT_WMAPRO) || (pcodec->audio_type == AFORMAT_PCM_S16BE) 00451 || (pcodec->audio_type == AFORMAT_PCM_S16LE) || (pcodec->audio_type == AFORMAT_PCM_U8) 00452 || (pcodec->audio_type == AFORMAT_PCM_BLURAY)||(pcodec->audio_type == AFORMAT_AMR)) {*/ 00453 if(IS_AUIDO_NEED_EXT_INFO(pcodec->audio_type)){ 00454 r = set_audio_info(pcodec); 00455 if (r < 0) { 00456 goto error1; 00457 } 00458 } 00459 } 00460 #ifdef SUBTITLE_EVENT 00461 if (pcodec->has_sub) { 00462 r = set_sub_format(pcodec); 00463 if (r < 0) { 00464 goto error1; 00465 } 00466 00467 r = codec_init_sub(pcodec); 00468 if (r < 0) { 00469 goto error1; 00470 } 00471 } 00472 #endif 00473 00474 return CODEC_ERROR_NONE; 00475 error1: 00476 codec_h_close(handle); 00477 codec_r = system_error_to_codec_error(r); 00478 print_error_msg(codec_r, errno, __FUNCTION__, __LINE__); 00479 return codec_r; 00480 00481 } 00482 00483 00484 /* --------------------------------------------------------------------------*/ 00492 /* --------------------------------------------------------------------------*/ 00493 static inline int codec_ts_init(codec_para_t *pcodec) 00494 { 00495 CODEC_HANDLE handle; 00496 int r; 00497 int flags = O_WRONLY; 00498 int codec_r; 00499 if (!((pcodec->has_video && IS_VALID_PID(pcodec->video_pid)) || 00500 (pcodec->has_audio && IS_VALID_PID(pcodec->audio_pid)))) { 00501 return -CODEC_ERROR_PARAMETER; 00502 } 00503 00504 flags |= pcodec->noblock ? O_NONBLOCK : 0; 00505 handle = codec_h_open(CODEC_TS_DEVICE, flags); 00506 if (handle < 0) { 00507 codec_r = system_error_to_codec_error(handle); 00508 print_error_msg(codec_r, errno, __FUNCTION__, __LINE__); 00509 return CODEC_OPEN_HANDLE_FAILED; 00510 } 00511 pcodec->handle = handle; 00512 codec_set_demux_source(pcodec, DEMUX_PLAYER_SOURCE); 00513 if (pcodec->has_video) { 00514 r = set_video_format(pcodec); 00515 if (r < 0) { 00516 goto error1; 00517 } 00518 if ((pcodec->video_type == VFORMAT_H264) || (pcodec->video_type == VFORMAT_MPEG4)|| (pcodec->video_type == VFORMAT_VC1)|| (pcodec->video_type == VFORMAT_AVS)|| (pcodec->video_type == VFORMAT_MPEG12)) { 00519 r = set_video_codec_info(pcodec); 00520 if (r < 0) { 00521 codec_h_close(handle); 00522 codec_r = system_error_to_codec_error(r); 00523 print_error_msg(codec_r, errno, __FUNCTION__, __LINE__); 00524 return codec_r; 00525 } 00526 } 00527 } 00528 if (pcodec->has_audio) { 00529 r = set_audio_format(pcodec); 00530 if (r < 0) { 00531 goto error1; 00532 } 00533 00534 /*if ((pcodec->audio_type == AFORMAT_ADPCM) || (pcodec->audio_type == AFORMAT_WMA) || (pcodec->audio_type == AFORMAT_WMAPRO) || (pcodec->audio_type == AFORMAT_PCM_S16BE) 00535 || (pcodec->audio_type == AFORMAT_PCM_S16LE) || (pcodec->audio_type == AFORMAT_PCM_U8) 00536 || (pcodec->audio_type == AFORMAT_PCM_BLURAY)||(pcodec->audio_type == AFORMAT_AMR))*/ 00537 if(pcodec->audio_info.valid){ 00538 r = set_audio_info(pcodec); 00539 if (r < 0) { 00540 goto error1; 00541 } 00542 } 00543 } 00544 00545 r = set_ts_skip_byte(pcodec); 00546 if (r < 0) { 00547 goto error1; 00548 } 00549 00550 #ifdef SUBTITLE_EVENT 00551 if (pcodec->has_sub) { 00552 r = set_sub_format(pcodec); 00553 if (r < 0) { 00554 goto error1; 00555 } 00556 00557 r = codec_init_sub(pcodec); 00558 if (r < 0) { 00559 goto error1; 00560 } 00561 } 00562 #endif 00563 return CODEC_ERROR_NONE; 00564 error1: 00565 codec_h_close(handle); 00566 codec_r = system_error_to_codec_error(r); 00567 print_error_msg(codec_r, errno, __FUNCTION__, __LINE__); 00568 return codec_r; 00569 00570 } 00571 00572 /* --------------------------------------------------------------------------*/ 00580 /* --------------------------------------------------------------------------*/ 00581 static inline int codec_rm_init(codec_para_t *pcodec) 00582 { 00583 CODEC_HANDLE handle; 00584 int r; 00585 int flags = O_WRONLY; 00586 int codec_r; 00587 if (!((pcodec->has_video && IS_VALID_PID(pcodec->video_pid)) || 00588 (pcodec->has_audio && IS_VALID_PID(pcodec->audio_pid)))) { 00589 CODEC_PRINT("codec_rm_init failed! video=%d vpid=%d audio=%d apid=%d\n", pcodec->has_video, pcodec->video_pid, pcodec->has_audio, pcodec->audio_pid); 00590 return -CODEC_ERROR_PARAMETER; 00591 } 00592 flags |= pcodec->noblock ? O_NONBLOCK : 0; 00593 handle = codec_h_open(CODEC_RM_DEVICE, flags); 00594 if (handle < 0) { 00595 codec_r = system_error_to_codec_error(handle); 00596 print_error_msg(codec_r, errno, __FUNCTION__, __LINE__); 00597 return CODEC_OPEN_HANDLE_FAILED; 00598 } 00599 00600 pcodec->handle = handle; 00601 if (pcodec->has_video) { 00602 r = set_video_format(pcodec); 00603 if (r < 0) { 00604 goto error1; 00605 } 00606 00607 r = set_video_codec_info(pcodec); 00608 if (r < 0) { 00609 goto error1; 00610 } 00611 } 00612 if (pcodec->has_audio) { 00613 r = set_audio_format(pcodec); 00614 if (r < 0) { 00615 goto error1; 00616 } 00617 r = set_audio_info(pcodec); 00618 if (r < 0) { 00619 goto error1; 00620 } 00621 } 00622 return CODEC_ERROR_NONE; 00623 00624 error1: 00625 codec_h_close(handle); 00626 codec_r = system_error_to_codec_error(r); 00627 print_error_msg(codec_r, errno, __FUNCTION__, __LINE__); 00628 return codec_r; 00629 } 00630 00631 /* --------------------------------------------------------------------------*/ 00639 /* --------------------------------------------------------------------------*/ 00640 int codec_init(codec_para_t *pcodec) 00641 { 00642 int ret; 00643 //if(pcodec->has_audio) 00644 // audio_stop(); 00645 pcodec->handle = -1; 00646 pcodec->cntl_handle = -1; 00647 pcodec->sub_handle = -1; 00648 pcodec->audio_utils_handle = -1; 00649 if(pcodec->audio_type==AFORMAT_MPEG1 || pcodec->audio_type==AFORMAT_MPEG2) 00650 pcodec->audio_type=AFORMAT_MPEG; 00651 switch (pcodec->stream_type) { 00652 case STREAM_TYPE_ES_VIDEO: 00653 ret = codec_video_es_init(pcodec); 00654 break; 00655 case STREAM_TYPE_ES_AUDIO: 00656 ret = codec_audio_es_init(pcodec); 00657 break; 00658 case STREAM_TYPE_ES_SUB: 00659 ret = codec_sub_es_init(pcodec); 00660 break; 00661 case STREAM_TYPE_PS: 00662 ret = codec_ps_init(pcodec); 00663 break; 00664 case STREAM_TYPE_TS: 00665 ret = codec_ts_init(pcodec); 00666 break; 00667 case STREAM_TYPE_RM: 00668 ret = codec_rm_init(pcodec); 00669 break; 00670 case STREAM_TYPE_UNKNOW: 00671 default: 00672 return -CODEC_ERROR_STREAM_TYPE_UNKNOW; 00673 } 00674 if (ret != 0) { 00675 return ret; 00676 } 00677 ret = codec_init_cntl(pcodec); 00678 if (ret != CODEC_ERROR_NONE) { 00679 return ret; 00680 } 00681 ret = codec_change_buf_size(pcodec); 00682 if (ret != 0) { 00683 return -CODEC_ERROR_SET_BUFSIZE_FAILED; 00684 } 00685 ret = codec_h_control(pcodec->handle, AMSTREAM_IOC_PORT_INIT, 0); 00686 if (ret != 0) { 00687 00688 return -CODEC_ERROR_INIT_FAILED; 00689 } 00690 if (pcodec->has_audio) { 00691 arm_audio_info a_ainfo; 00692 memset(&a_ainfo,0,sizeof(arm_audio_info)); 00693 a_ainfo.channels=pcodec->audio_channels; 00694 a_ainfo.sample_rate=pcodec->audio_samplerate; 00695 a_ainfo.format=pcodec->audio_type; 00696 a_ainfo.handle=pcodec->handle; 00697 a_ainfo.SessionID=pcodec->SessionID; 00698 a_ainfo.dspdec_not_supported = pcodec->dspdec_not_supported; 00699 a_ainfo.droppcm_flag = 0; 00700 a_ainfo.bitrate =pcodec->audio_info.bitrate; 00701 a_ainfo.block_align=pcodec->audio_info.block_align; 00702 a_ainfo.codec_id =pcodec->audio_info.codec_id; 00703 a_ainfo.automute =pcodec->automute_flag; 00704 if(IS_AUIDO_NEED_EXT_INFO(pcodec->audio_type)) 00705 { 00706 if(pcodec->audio_type!=AFORMAT_WMA && pcodec->audio_type!=AFORMAT_WMAPRO) 00707 { 00708 a_ainfo.extradata_size=pcodec->audio_info.extradata_size; 00709 if(a_ainfo.extradata_size>0&&a_ainfo.extradata_size<=AUDIO_EXTRA_DATA_SIZE) 00710 memcpy((char*)a_ainfo.extradata,pcodec->audio_info.extradata,a_ainfo.extradata_size); 00711 else 00712 a_ainfo.extradata_size=0; 00713 }else{ 00714 Asf_audio_info_t asfinfo={0}; 00715 asfinfo.bitrate =pcodec->audio_info.bitrate; 00716 asfinfo.block_align=pcodec->audio_info.block_align; 00717 asfinfo.channels =pcodec->audio_info.channels; 00718 asfinfo.codec_id =pcodec->audio_info.codec_id; 00719 asfinfo.sample_rate=pcodec->audio_info.sample_rate; 00720 asfinfo.valid =pcodec->audio_info.valid; 00721 if(pcodec->audio_info.extradata_size<=512){ 00722 memcpy(asfinfo.extradata,pcodec->audio_info.extradata,pcodec->audio_info.extradata_size); 00723 asfinfo.extradata_size=pcodec->audio_info.extradata_size; 00724 } 00725 memcpy((char*)a_ainfo.extradata,&asfinfo,sizeof(Asf_audio_info_t)); 00726 a_ainfo.extradata_size=sizeof(Asf_audio_info_t); 00727 } 00728 } 00729 audio_start(&pcodec->adec_priv, &a_ainfo); 00730 if(pcodec->avsync_threshold > 0) 00731 audio_set_avsync_threshold(pcodec->adec_priv, pcodec->avsync_threshold); 00732 } 00733 return ret; 00734 } 00735 00736 void codec_audio_basic_init(void) 00737 { 00738 audio_basic_init(); 00739 } 00740 00741 /* --------------------------------------------------------------------------*/ 00751 /* --------------------------------------------------------------------------*/ 00752 int codec_write(codec_para_t *pcodec, void *buffer, int len) 00753 { 00754 return codec_h_write(pcodec->handle, buffer, len); 00755 } 00756 00757 /* --------------------------------------------------------------------------*/ 00767 /* --------------------------------------------------------------------------*/ 00768 int codec_read(codec_para_t *pcodec, void *buffer, int len) 00769 { 00770 return codec_h_read(pcodec->handle, buffer, len); 00771 } 00772 00773 /* --------------------------------------------------------------------------*/ 00781 /* --------------------------------------------------------------------------*/ 00782 int codec_close(codec_para_t *pcodec) 00783 { 00784 int res = 0; 00785 00786 if (pcodec->has_audio) { 00787 audio_stop(&pcodec->adec_priv); 00788 CODEC_PRINT("[%s]audio stop OK!\n", __FUNCTION__); 00789 } 00790 #ifdef SUBTITLE_EVENT 00791 if (pcodec->has_sub && pcodec->sub_handle >= 0) { 00792 res |= codec_close_sub_fd(pcodec->sub_handle); 00793 } 00794 #endif 00795 00796 res |= codec_close_cntl(pcodec); 00797 res |= codec_h_close(pcodec->handle); 00798 return res; 00799 } 00800 00801 /* --------------------------------------------------------------------------*/ 00807 /* --------------------------------------------------------------------------*/ 00808 void codec_close_audio(codec_para_t *pcodec) 00809 { 00810 if (pcodec) { 00811 pcodec->has_audio = 0; 00812 } 00813 audio_stop(&pcodec->adec_priv); 00814 return; 00815 } 00816 00817 /* --------------------------------------------------------------------------*/ 00823 /* --------------------------------------------------------------------------*/ 00824 void codec_close_audio_async(codec_para_t *pcodec) 00825 { 00826 if(pcodec) 00827 audio_stop_async(&pcodec->adec_priv); 00828 return; 00829 } 00830 00831 /* --------------------------------------------------------------------------*/ 00838 /* --------------------------------------------------------------------------*/ 00839 void codec_resume_audio(codec_para_t *pcodec, unsigned int orig) 00840 { 00841 pcodec->has_audio = orig; 00842 if (pcodec->has_audio) { 00843 arm_audio_info a_ainfo; 00844 memset(&a_ainfo,0,sizeof(arm_audio_info)); 00845 a_ainfo.channels=pcodec->audio_channels; 00846 a_ainfo.sample_rate=pcodec->audio_samplerate; 00847 a_ainfo.format=pcodec->audio_type; 00848 a_ainfo.handle=pcodec->handle; 00849 a_ainfo.dspdec_not_supported = pcodec->dspdec_not_supported; 00850 a_ainfo.bitrate =pcodec->audio_info.bitrate; 00851 a_ainfo.block_align=pcodec->audio_info.block_align; 00852 a_ainfo.codec_id =pcodec->audio_info.codec_id; 00853 a_ainfo.automute =pcodec->automute_flag; 00854 if (pcodec->switch_audio_flag) { 00855 a_ainfo.droppcm_flag = pcodec->switch_audio_flag; 00856 if(pcodec->stream_type == STREAM_TYPE_TS || pcodec->stream_type == STREAM_TYPE_PS) 00857 a_ainfo.droppcm_flag = 0; 00858 pcodec->switch_audio_flag = 0; 00859 } 00860 if(IS_AUIDO_NEED_EXT_INFO(pcodec->audio_type)) 00861 { 00862 if(pcodec->audio_type!=AFORMAT_WMA && pcodec->audio_type!=AFORMAT_WMAPRO) 00863 { 00864 a_ainfo.extradata_size=pcodec->audio_info.extradata_size; 00865 if(a_ainfo.extradata_size>0&&a_ainfo.extradata_size<=AUDIO_EXTRA_DATA_SIZE) 00866 memcpy((char*)a_ainfo.extradata,pcodec->audio_info.extradata,a_ainfo.extradata_size); 00867 else 00868 a_ainfo.extradata_size=0; 00869 }else{ 00870 Asf_audio_info_t asfinfo={0}; 00871 asfinfo.bitrate =pcodec->audio_info.bitrate; 00872 asfinfo.block_align=pcodec->audio_info.block_align; 00873 asfinfo.channels =pcodec->audio_info.channels; 00874 asfinfo.codec_id =pcodec->audio_info.codec_id; 00875 asfinfo.sample_rate=pcodec->audio_info.sample_rate; 00876 asfinfo.valid =pcodec->audio_info.valid; 00877 if(pcodec->audio_info.extradata_size<=512){ 00878 memcpy(asfinfo.extradata,pcodec->audio_info.extradata,pcodec->audio_info.extradata_size); 00879 asfinfo.extradata_size=pcodec->audio_info.extradata_size; 00880 } 00881 memcpy((char*)a_ainfo.extradata,&asfinfo,sizeof(Asf_audio_info_t)); 00882 a_ainfo.extradata_size=sizeof(Asf_audio_info_t); 00883 } 00884 } 00885 audio_start(&pcodec->adec_priv, &a_ainfo); 00886 } 00887 return; 00888 } 00889 00890 /* --------------------------------------------------------------------------*/ 00899 /* --------------------------------------------------------------------------*/ 00900 int codec_checkin_pts(codec_para_t *pcodec, unsigned long pts) 00901 { 00902 //CODEC_PRINT("[%s:%d]pts=%x(%d)\n",__FUNCTION__,__LINE__,pts,pts/90000); 00903 return codec_h_control(pcodec->handle, AMSTREAM_IOC_TSTAMP, pts); 00904 } 00905 00906 /* --------------------------------------------------------------------------*/ 00915 /* --------------------------------------------------------------------------*/ 00916 int codec_get_vbuf_state(codec_para_t *p, struct buf_status *buf) 00917 { 00918 int r; 00919 struct am_io_param am_io; 00920 r = codec_h_control(p->handle, AMSTREAM_IOC_VB_STATUS, (unsigned long)&am_io); 00921 memcpy(buf, &am_io.status, sizeof(*buf)); 00922 return system_error_to_codec_error(r); 00923 } 00924 /* --------------------------------------------------------------------------*/ 00933 /* --------------------------------------------------------------------------*/ 00934 int codec_get_abuf_state(codec_para_t *p, struct buf_status *buf) 00935 { 00936 int r; 00937 struct am_io_param am_io; 00938 r = codec_h_control(p->handle, AMSTREAM_IOC_AB_STATUS, (unsigned long)&am_io); 00939 memcpy(buf, &am_io.status, sizeof(*buf)); 00940 return system_error_to_codec_error(r); 00941 } 00942 00943 /* --------------------------------------------------------------------------*/ 00952 /* --------------------------------------------------------------------------*/ 00953 int codec_get_vdec_state(codec_para_t *p, struct vdec_status *vdec) 00954 { 00955 int r; 00956 struct am_io_param am_io; 00957 r = codec_h_control(p->handle, AMSTREAM_IOC_VDECSTAT, (unsigned long)&am_io); 00958 if (r < 0) { 00959 CODEC_PRINT("[codec_get_vdec_state]error[%d]: %s\n", r, codec_error_msg(system_error_to_codec_error(r))); 00960 } 00961 memcpy(vdec, &am_io.vstatus, sizeof(*vdec)); 00962 return system_error_to_codec_error(r); 00963 } 00964 00965 /* --------------------------------------------------------------------------*/ 00974 /* --------------------------------------------------------------------------*/ 00975 int codec_get_adec_state(codec_para_t *p, struct adec_status *adec) 00976 { 00977 if(get_audio_decoder() ==AUDIO_ARM_DECODER) 00978 return get_decoder_status(p->adec_priv,adec); 00979 int r; 00980 struct am_io_param am_io; 00981 r = codec_h_control(p->handle, AMSTREAM_IOC_ADECSTAT, (unsigned long)&am_io); 00982 if(r == 0){ 00983 memcpy(adec, &am_io.astatus, sizeof(*adec)); 00984 } 00985 return system_error_to_codec_error(r); 00986 } 00987 00988 /* --------------------------------------------------------------------------*/ 00996 /* --------------------------------------------------------------------------*/ 00997 static int video_pause(codec_para_t *p) 00998 { 00999 CODEC_PRINT("video_pause!\n"); 01000 return codec_h_control(p->cntl_handle, AMSTREAM_IOC_VPAUSE, 1); 01001 } 01002 01003 /* --------------------------------------------------------------------------*/ 01011 /* --------------------------------------------------------------------------*/ 01012 static int video_resume(codec_para_t *p) 01013 { 01014 CODEC_PRINT("video_resume!\n"); 01015 return codec_h_control(p->cntl_handle, AMSTREAM_IOC_VPAUSE, 0); 01016 } 01017 01018 /* --------------------------------------------------------------------------*/ 01026 /* --------------------------------------------------------------------------*/ 01027 int codec_pause(codec_para_t *p) 01028 { 01029 int ret = CODEC_ERROR_NONE; 01030 if (p) { 01031 CODEC_PRINT("[codec_pause]p->has_audio=%d\n", p->has_audio); 01032 if(p->has_audio) { 01033 audio_pause(p->adec_priv); 01034 } 01035 if(p->has_video){ 01036 ret = video_pause(p); 01037 } 01038 } else { 01039 ret = CODEC_ERROR_PARAMETER; 01040 } 01041 return ret; 01042 } 01043 /* --------------------------------------------------------------------------*/ 01051 /* --------------------------------------------------------------------------*/ 01052 int codec_resume(codec_para_t *p) 01053 { 01054 int ret = CODEC_ERROR_NONE; 01055 if (p) { 01056 CODEC_PRINT("[codec_resume]p->has_audio=%d\n", p->has_audio); 01057 if(p->has_audio){ 01058 audio_resume(p->adec_priv); 01059 } 01060 if(p->has_video){ 01061 ret = video_resume(p); 01062 } 01063 } else { 01064 ret = CODEC_ERROR_PARAMETER; 01065 } 01066 return ret; 01067 } 01068 01069 /* --------------------------------------------------------------------------*/ 01077 /* --------------------------------------------------------------------------*/ 01078 int codec_reset(codec_para_t *p) 01079 { 01080 int ret; 01081 ret = codec_close(p); 01082 if (ret != 0) { 01083 return ret; 01084 } 01085 ret = codec_init(p); 01086 CODEC_PRINT("[%s:%d]ret=%x\n", __FUNCTION__, __LINE__, ret); 01087 return system_error_to_codec_error(ret); 01088 } 01089 01090 /* --------------------------------------------------------------------------*/ 01098 /* --------------------------------------------------------------------------*/ 01099 int codec_init_sub(codec_para_t *pcodec) 01100 { 01101 CODEC_HANDLE sub_handle; 01102 int flags = O_WRONLY; 01103 flags |= pcodec->noblock ? O_NONBLOCK : 0; 01104 sub_handle = codec_h_open(CODEC_SUB_DEVICE, flags); 01105 if (sub_handle < 0) { 01106 CODEC_PRINT("get %s failed\n", CODEC_SUB_DEVICE); 01107 return system_error_to_codec_error(sub_handle); 01108 } 01109 01110 pcodec->sub_handle = sub_handle; 01111 return CODEC_ERROR_NONE; 01112 } 01113 01114 /* --------------------------------------------------------------------------*/ 01120 /* --------------------------------------------------------------------------*/ 01121 int codec_open_sub_read(void) 01122 { 01123 CODEC_HANDLE sub_handle; 01124 01125 sub_handle = codec_h_open_rd(CODEC_SUB_READ_DEVICE); 01126 if (sub_handle < 0) { 01127 CODEC_PRINT("get %s failed\n", CODEC_SUB_READ_DEVICE); 01128 return system_error_to_codec_error(sub_handle); 01129 } 01130 01131 return sub_handle; 01132 } 01133 01134 /* --------------------------------------------------------------------------*/ 01142 /* --------------------------------------------------------------------------*/ 01143 int codec_close_sub(codec_para_t *pcodec) 01144 { 01145 int res = CODEC_ERROR_NONE; 01146 01147 if (pcodec) { 01148 if (pcodec->sub_handle) { 01149 res = codec_h_close(pcodec->sub_handle); 01150 } 01151 } 01152 return res; 01153 } 01154 01155 /* --------------------------------------------------------------------------*/ 01163 /* --------------------------------------------------------------------------*/ 01164 int codec_close_sub_fd(CODEC_HANDLE sub_fd) 01165 { 01166 int res = CODEC_ERROR_NONE; 01167 01168 if (sub_fd) { 01169 res = codec_h_close(sub_fd); 01170 } 01171 return res; 01172 } 01173 01174 /* --------------------------------------------------------------------------*/ 01182 /* --------------------------------------------------------------------------*/ 01183 int codec_poll_sub(codec_para_t *pcodec) 01184 { 01185 struct pollfd sub_poll_fd[1]; 01186 01187 if (pcodec->sub_handle == 0) { 01188 return 0; 01189 } 01190 01191 sub_poll_fd[0].fd = pcodec->sub_handle; 01192 sub_poll_fd[0].events = POLLOUT; 01193 01194 return poll(sub_poll_fd, 1, 10); 01195 } 01196 01197 /* --------------------------------------------------------------------------*/ 01206 /* --------------------------------------------------------------------------*/ 01207 int codec_poll_sub_fd(CODEC_HANDLE sub_fd, int timeout) 01208 { 01209 struct pollfd sub_poll_fd[1]; 01210 01211 if (sub_fd <= 0) { 01212 return 0; 01213 } 01214 01215 sub_poll_fd[0].fd = sub_fd; 01216 sub_poll_fd[0].events = POLLOUT; 01217 01218 return poll(sub_poll_fd, 1, timeout); 01219 } 01220 01221 /* --------------------------------------------------------------------------*/ 01229 /* --------------------------------------------------------------------------*/ 01230 int codec_get_sub_size(codec_para_t *pcodec) 01231 { 01232 int sub_size, r; 01233 01234 if (pcodec->sub_handle == 0) { 01235 CODEC_PRINT("no control handler\n"); 01236 return 0; 01237 } 01238 01239 r = codec_h_control(pcodec->sub_handle, AMSTREAM_IOC_SUB_LENGTH, (unsigned long)&sub_size); 01240 if (r < 0) { 01241 return system_error_to_codec_error(r); 01242 } else { 01243 return sub_size; 01244 } 01245 } 01246 01247 /* --------------------------------------------------------------------------*/ 01255 /* --------------------------------------------------------------------------*/ 01256 int codec_get_sub_size_fd(CODEC_HANDLE sub_fd) 01257 { 01258 int sub_size, r; 01259 01260 if (sub_fd <= 0) { 01261 CODEC_PRINT("no sub handler\n"); 01262 return 0; 01263 } 01264 01265 r = codec_h_control(sub_fd, AMSTREAM_IOC_SUB_LENGTH, (unsigned long)&sub_size); 01266 if (r < 0) { 01267 return system_error_to_codec_error(r); 01268 } else { 01269 return sub_size; 01270 } 01271 } 01272 01273 /* --------------------------------------------------------------------------*/ 01283 /* --------------------------------------------------------------------------*/ 01284 int codec_read_sub_data(codec_para_t *pcodec, char *buf, unsigned int length) 01285 { 01286 int data_size = length, r, read_done = 0; 01287 01288 if (pcodec->sub_handle == 0) { 01289 CODEC_PRINT("no control handler\n"); 01290 return 0; 01291 } 01292 01293 while (data_size) { 01294 r = codec_h_read(pcodec->sub_handle, buf + read_done, data_size); 01295 if (r < 0) { 01296 return system_error_to_codec_error(r); 01297 } else { 01298 data_size -= r; 01299 read_done += r; 01300 } 01301 } 01302 01303 return 0; 01304 } 01305 01306 /* --------------------------------------------------------------------------*/ 01316 /* --------------------------------------------------------------------------*/ 01317 int codec_read_sub_data_fd(CODEC_HANDLE sub_fd, char *buf, unsigned int length) 01318 { 01319 int data_size = length, r, read_done = 0; 01320 01321 if (sub_fd <= 0) { 01322 CODEC_PRINT("no sub handler\n"); 01323 return 0; 01324 } 01325 01326 while (data_size) { 01327 r = codec_h_read(sub_fd, buf + read_done, data_size); 01328 if (r < 0) { 01329 return system_error_to_codec_error(r); 01330 } else { 01331 data_size -= r; 01332 read_done += r; 01333 } 01334 } 01335 01336 return 0; 01337 } 01338 01339 /* --------------------------------------------------------------------------*/ 01349 /* --------------------------------------------------------------------------*/ 01350 int codec_write_sub_data(codec_para_t *pcodec, char *buf, unsigned int length) 01351 { 01352 if (pcodec->sub_handle == 0) { 01353 CODEC_PRINT("no control handler\n"); 01354 return 0; 01355 } 01356 01357 return codec_h_write(pcodec->sub_handle, buf, length); 01358 } 01359 01360 /* --------------------------------------------------------------------------*/ 01368 /* --------------------------------------------------------------------------*/ 01369 int codec_init_cntl(codec_para_t *pcodec) 01370 { 01371 CODEC_HANDLE cntl; 01372 01373 01374 cntl = codec_h_open(CODEC_CNTL_DEVICE, O_RDWR); 01375 if (cntl < 0) { 01376 CODEC_PRINT("get %s failed\n", CODEC_CNTL_DEVICE); 01377 return system_error_to_codec_error(cntl); 01378 } 01379 01380 pcodec->cntl_handle = cntl; 01381 01382 return CODEC_ERROR_NONE; 01383 } 01384 01385 /* --------------------------------------------------------------------------*/ 01393 /* --------------------------------------------------------------------------*/ 01394 int codec_close_cntl(codec_para_t *pcodec) 01395 { 01396 int res = CODEC_ERROR_NONE; 01397 01398 if (pcodec) { 01399 if (pcodec->cntl_handle) { 01400 res = codec_h_control(pcodec->cntl_handle, AMSTREAM_IOC_CLEAR_VIDEO, 0); 01401 res = codec_h_close(pcodec->cntl_handle); 01402 } 01403 } 01404 return res; 01405 } 01406 01407 /* --------------------------------------------------------------------------*/ 01415 /* --------------------------------------------------------------------------*/ 01416 int codec_poll_cntl(codec_para_t *pcodec) 01417 { 01418 struct pollfd codec_poll_fd[1]; 01419 01420 if (pcodec->cntl_handle == 0) { 01421 return 0; 01422 } 01423 01424 codec_poll_fd[0].fd = pcodec->cntl_handle; 01425 codec_poll_fd[0].events = POLLOUT; 01426 01427 return poll(codec_poll_fd, 1, 10); 01428 } 01429 01430 /* --------------------------------------------------------------------------*/ 01438 /* --------------------------------------------------------------------------*/ 01439 int codec_get_cntl_state(codec_para_t *pcodec) 01440 { 01441 int cntl_state, r; 01442 01443 if (pcodec->cntl_handle == 0) { 01444 CODEC_PRINT("no control handler\n"); 01445 return 0; 01446 } 01447 01448 r = codec_h_control(pcodec->cntl_handle, AMSTREAM_IOC_TRICK_STAT, (unsigned long)&cntl_state); 01449 if (r < 0) { 01450 return system_error_to_codec_error(r); 01451 } else { 01452 return cntl_state; 01453 } 01454 } 01455 01456 /* --------------------------------------------------------------------------*/ 01465 /* --------------------------------------------------------------------------*/ 01466 int codec_set_cntl_mode(codec_para_t *pcodec, unsigned int mode) 01467 { 01468 return codec_h_control(pcodec->cntl_handle, AMSTREAM_IOC_TRICKMODE, (unsigned long)mode); 01469 } 01470 01471 int codec_set_mode(codec_para_t *pcodec, unsigned int mode) 01472 { 01473 return codec_h_control(pcodec->handle, AMSTREAM_IOC_TRICKMODE, (unsigned long)mode); 01474 } 01475 /* --------------------------------------------------------------------------*/ 01484 /* --------------------------------------------------------------------------*/ 01485 int codec_set_cntl_avthresh(codec_para_t *pcodec, unsigned int avthresh) 01486 { 01487 return codec_h_control(pcodec->cntl_handle, AMSTREAM_IOC_AVTHRESH, (unsigned long)avthresh); 01488 } 01489 01490 /* --------------------------------------------------------------------------*/ 01500 /* --------------------------------------------------------------------------*/ 01501 int codec_set_cntl_syncthresh(codec_para_t *pcodec, unsigned int syncthresh) 01502 { 01503 return codec_h_control(pcodec->cntl_handle, AMSTREAM_IOC_SYNCTHRESH, (unsigned long)syncthresh); 01504 } 01505 01506 /* --------------------------------------------------------------------------*/ 01514 /* --------------------------------------------------------------------------*/ 01515 int codec_reset_audio(codec_para_t *pcodec) 01516 { 01517 return codec_h_control(pcodec->handle, AMSTREAM_IOC_AUDIO_RESET, 0); 01518 } 01519 01520 /* --------------------------------------------------------------------------*/ 01528 /* --------------------------------------------------------------------------*/ 01529 int codec_reset_subtile(codec_para_t *pcodec) 01530 { 01531 return codec_h_control(pcodec->handle, AMSTREAM_IOC_SUB_RESET, 0); 01532 } 01533 01534 /* --------------------------------------------------------------------------*/ 01542 /* --------------------------------------------------------------------------*/ 01543 int codec_set_audio_pid(codec_para_t *pcodec) 01544 { 01545 return codec_h_control(pcodec->handle, AMSTREAM_IOC_AID, pcodec->audio_pid); 01546 } 01547 01548 /* --------------------------------------------------------------------------*/ 01556 /* --------------------------------------------------------------------------*/ 01557 int codec_set_sub_id(codec_para_t *pcodec) 01558 { 01559 return codec_h_control(pcodec->handle, AMSTREAM_IOC_SID, pcodec->sub_pid); 01560 } 01561 01562 /* --------------------------------------------------------------------------*/ 01570 /* --------------------------------------------------------------------------*/ 01571 int codec_set_sub_type(codec_para_t *pcodec) 01572 { 01573 return codec_h_control(pcodec->handle, AMSTREAM_IOC_SUB_TYPE, pcodec->sub_type); 01574 } 01575 01576 /* --------------------------------------------------------------------------*/ 01584 /* --------------------------------------------------------------------------*/ 01585 int codec_audio_reinit(codec_para_t *pcodec) 01586 { 01587 int ret; 01588 ret = set_audio_format(pcodec); 01589 if(!ret && pcodec->audio_info.valid){ 01590 ret = set_audio_info(pcodec); 01591 } 01592 return ret; 01593 } 01594 01595 /* --------------------------------------------------------------------------*/ 01603 /* --------------------------------------------------------------------------*/ 01604 int codec_set_dec_reset(codec_para_t *pcodec) 01605 { 01606 return codec_h_control(pcodec->handle, AMSTREAM_IOC_SET_DEC_RESET, 0); 01607 } 01608 01609 /* --------------------------------------------------------------------------*/ 01617 /* --------------------------------------------------------------------------*/ 01618 int codec_audio_isready(codec_para_t *p) 01619 { 01620 int audio_isready = 1; 01621 if (!p) { 01622 CODEC_PRINT("[%s]ERROR invalid pointer!\n", __FUNCTION__); 01623 return -1; 01624 } 01625 if (p->has_audio) { 01626 audio_isready = audio_dec_ready(p->adec_priv); 01627 } 01628 01629 return audio_isready; 01630 } 01631 01632 /* --------------------------------------------------------------------------*/ 01640 /* --------------------------------------------------------------------------*/ 01641 int codec_audio_get_nb_frames(codec_para_t *p) 01642 { 01643 int audio_nb_frames = -1; 01644 if (!p) { 01645 CODEC_PRINT("[%s]ERROR invalid pointer!\n", __FUNCTION__); 01646 return -1; 01647 } 01648 01649 if (p->has_audio) { 01650 audio_nb_frames = audio_get_decoded_nb_frames(p->adec_priv); 01651 } 01652 //CODEC_PRINT("[%s]get audio decoded frame number[%d]!\n", __FUNCTION__, audio_nb_frames); 01653 return audio_nb_frames; 01654 } 01655 01656 /* --------------------------------------------------------------------------*/ 01664 /* --------------------------------------------------------------------------*/ 01665 int codec_get_apts(codec_para_t *pcodec) 01666 { 01667 unsigned int apts; 01668 int ret; 01669 01670 if (!pcodec) { 01671 CODEC_PRINT("[%s]ERROR invalid pointer!\n", __FUNCTION__); 01672 return -1; 01673 } 01674 01675 ret = codec_h_control(pcodec->handle, AMSTREAM_IOC_APTS, (unsigned long)&apts); 01676 if (ret < 0) { 01677 CODEC_PRINT("[%s]ioctl failed %d\n", __FUNCTION__, ret); 01678 return -1; 01679 } 01680 01681 return apts; 01682 } 01683 01684 /* --------------------------------------------------------------------------*/ 01692 /* --------------------------------------------------------------------------*/ 01693 int codec_get_vpts(codec_para_t *pcodec) 01694 { 01695 unsigned int vpts; 01696 int ret; 01697 01698 if (!pcodec) { 01699 CODEC_PRINT("[%s]ERROR invalid pointer!\n", __FUNCTION__); 01700 return -1; 01701 } 01702 01703 ret = codec_h_control(pcodec->handle, AMSTREAM_IOC_VPTS, (unsigned long)&vpts); 01704 if (ret < 0) { 01705 CODEC_PRINT("[%s]ioctl failed %d\n", __FUNCTION__, ret); 01706 return -1; 01707 } 01708 01709 return vpts; 01710 } 01711 01712 /* --------------------------------------------------------------------------*/ 01720 /* --------------------------------------------------------------------------*/ 01721 int codec_get_pcrscr(codec_para_t *pcodec) 01722 { 01723 unsigned int pcrscr; 01724 int ret; 01725 01726 if (!pcodec) { 01727 CODEC_PRINT("[%s]ERROR invalid pointer!\n", __FUNCTION__); 01728 return -1; 01729 } 01730 01731 ret = codec_h_control(pcodec->handle, AMSTREAM_IOC_PCRSCR, (unsigned long)&pcrscr); 01732 if (ret < 0) { 01733 CODEC_PRINT("[%s]ioctl failed %d\n", __FUNCTION__, ret); 01734 return -1; 01735 } 01736 01737 return pcrscr; 01738 } 01739 01740 /* --------------------------------------------------------------------------*/ 01749 /* --------------------------------------------------------------------------*/ 01750 int codec_set_pcrscr(codec_para_t *pcodec, int val) 01751 { 01752 unsigned int pcrscr; 01753 int ret; 01754 01755 if (!pcodec) { 01756 CODEC_PRINT("[%s]ERROR invalid pointer!\n", __FUNCTION__); 01757 return -1; 01758 } 01759 01760 ret = codec_h_control(pcodec->handle, AMSTREAM_IOC_SET_PCRSCR, val); 01761 if (ret < 0) { 01762 CODEC_PRINT("[%s]ioctl failed %d\n", __FUNCTION__, ret); 01763 return -1; 01764 } 01765 01766 return 0; 01767 } 01768 01769 /* --------------------------------------------------------------------------*/ 01778 /* --------------------------------------------------------------------------*/ 01779 int codec_set_syncenable(codec_para_t *pcodec, int enable) 01780 { 01781 return codec_h_control(pcodec->cntl_handle, AMSTREAM_IOC_SYNCENABLE, (unsigned long)enable); 01782 } 01783 01784 /* --------------------------------------------------------------------------*/ 01793 /* --------------------------------------------------------------------------*/ 01794 int codec_set_sync_audio_discont(codec_para_t *pcodec, int discontinue) 01795 { 01796 return codec_h_control(pcodec->cntl_handle, AMSTREAM_IOC_SET_SYNC_ADISCON, (unsigned long)discontinue); 01797 } 01798 01799 /* --------------------------------------------------------------------------*/ 01808 /* --------------------------------------------------------------------------*/ 01809 int codec_set_sync_video_discont(codec_para_t *pcodec, int discontinue) 01810 { 01811 return codec_h_control(pcodec->cntl_handle, AMSTREAM_IOC_SET_SYNC_VDISCON, (unsigned long)discontinue); 01812 } 01813 01814 /* --------------------------------------------------------------------------*/ 01822 /* --------------------------------------------------------------------------*/ 01823 int codec_get_sync_audio_discont(codec_para_t *pcodec) 01824 { 01825 int discontinue = 0; 01826 int ret; 01827 01828 ret = codec_h_control(pcodec->cntl_handle, AMSTREAM_IOC_GET_SYNC_ADISCON, (unsigned long)&discontinue); 01829 if (ret < 0) { 01830 return ret; 01831 } 01832 return discontinue; 01833 } 01834 01835 /* --------------------------------------------------------------------------*/ 01843 /* --------------------------------------------------------------------------*/ 01844 int codec_get_sync_video_discont(codec_para_t *pcodec) 01845 { 01846 int discontinue = 0; 01847 int ret; 01848 01849 ret = codec_h_control(pcodec->cntl_handle, AMSTREAM_IOC_GET_SYNC_VDISCON, (unsigned long)&discontinue); 01850 if (ret < 0) { 01851 return ret; 01852 } 01853 return discontinue; 01854 } 01855 01856 /* --------------------------------------------------------------------------*/ 01864 /* --------------------------------------------------------------------------*/ 01865 unsigned long codec_get_sync_audio_discont_diff(codec_para_t *pcodec) 01866 { 01867 unsigned long discontinue_diff = 0; 01868 int ret; 01869 01870 ret = codec_h_control(pcodec->cntl_handle, AMSTREAM_IOC_GET_SYNC_ADISCON_DIFF, (unsigned long)&discontinue_diff); 01871 if (ret < 0) { 01872 return ret; 01873 } 01874 return discontinue_diff; 01875 } 01876 01877 /* --------------------------------------------------------------------------*/ 01885 /* --------------------------------------------------------------------------*/ 01886 unsigned long codec_get_sync_video_discont_diff(codec_para_t *pcodec) 01887 { 01888 unsigned long discontinue_diff = 0; 01889 int ret; 01890 01891 ret = codec_h_control(pcodec->cntl_handle, AMSTREAM_IOC_GET_SYNC_VDISCON_DIFF, (unsigned long)&discontinue_diff); 01892 if (ret < 0) { 01893 return ret; 01894 } 01895 return discontinue_diff; 01896 } 01897 01898 /* --------------------------------------------------------------------------*/ 01907 /* --------------------------------------------------------------------------*/ 01908 int codec_set_sync_audio_discont_diff(codec_para_t *pcodec, unsigned long discontinue_diff) 01909 { 01910 return codec_h_control(pcodec->cntl_handle, AMSTREAM_IOC_SET_SYNC_ADISCON_DIFF, discontinue_diff); 01911 } 01912 01913 /* --------------------------------------------------------------------------*/ 01922 /* --------------------------------------------------------------------------*/ 01923 int codec_set_sync_video_discont_diff(codec_para_t *pcodec, unsigned long discontinue_diff) 01924 { 01925 return codec_h_control(pcodec->cntl_handle, AMSTREAM_IOC_SET_SYNC_VDISCON_DIFF, discontinue_diff); 01926 } 01927 01928 /* --------------------------------------------------------------------------*/ 01936 /* --------------------------------------------------------------------------*/ 01937 int codec_get_sub_num(codec_para_t *pcodec) 01938 { 01939 int sub_num = 0; 01940 int ret; 01941 01942 ret = codec_h_control(pcodec->handle, AMSTREAM_IOC_SUB_NUM, (unsigned long)&sub_num); 01943 if (ret < 0) { 01944 return ret; 01945 } 01946 return sub_num; 01947 } 01948 01949 /* --------------------------------------------------------------------------*/ 01958 /* --------------------------------------------------------------------------*/ 01959 int codec_get_sub_info(codec_para_t *pcodec, subtitle_info_t *sub_info) 01960 { 01961 int ret = 0; 01962 int i; 01963 if (!sub_info) { 01964 CODEC_PRINT("[codec_get_sub_info] error, NULL pointer!\n"); 01965 ret = CODEC_ERROR_INVAL; 01966 return ret; 01967 } 01968 ret = codec_h_control(pcodec->handle, AMSTREAM_IOC_SUB_INFO, (unsigned long)sub_info); 01969 if (ret < 0) { 01970 return ret; 01971 } 01972 return ret; 01973 } 01974 01975 /******************************************************************************** 01976 * 01977 *the interface for av sync threshold setting 01978 * 01979 *********************************************************************************/ 01980 int codec_set_av_threshold(codec_para_t *pcodec, int threshold) 01981 { 01982 int ret = 0; 01983 if (pcodec->has_audio) 01984 { 01985 audio_set_av_sync_threshold(pcodec->adec_priv, threshold); 01986 } 01987 else 01988 { 01989 CODEC_PRINT("[codec_set_av_threshold] error, no audio!\n"); 01990 ret = -1; 01991 } 01992 01993 return ret; 01994 } 01995 01996 /* --------------------------------------------------------------------------*/ 02004 /* --------------------------------------------------------------------------*/ 02005 int codec_get_freerun_mode(codec_para_t *pcodec) 02006 { 02007 int freerun_mode, r; 02008 02009 if (pcodec->cntl_handle == 0) { 02010 CODEC_PRINT("no control handler\n"); 02011 return 0; 02012 } 02013 02014 r = codec_h_control(pcodec->cntl_handle, AMSTREAM_IOC_GET_FREERUN_MODE, (unsigned long)&freerun_mode); 02015 if (r < 0) { 02016 return system_error_to_codec_error(r); 02017 } else { 02018 return freerun_mode; 02019 } 02020 } 02021 02022 /* --------------------------------------------------------------------------*/ 02031 /* --------------------------------------------------------------------------*/ 02032 int codec_set_freerun_mode(codec_para_t *pcodec, unsigned int mode) 02033 { 02034 return codec_h_control(pcodec->cntl_handle, AMSTREAM_IOC_SET_FREERUN_MODE, (unsigned long)mode); 02035 } 02036 02037 /* --------------------------------------------------------------------------*/ 02045 /* --------------------------------------------------------------------------*/ 02046 int codec_init_audio_utils(codec_para_t *pcodec) 02047 { 02048 CODEC_HANDLE audio_utils; 02049 02050 audio_utils = codec_h_open(CODEC_AUDIO_UTILS_DEVICE, O_RDONLY); 02051 if (audio_utils < 0) { 02052 CODEC_PRINT("get %s failed\n", CODEC_AUDIO_UTILS_DEVICE); 02053 return system_error_to_codec_error(audio_utils); 02054 } 02055 02056 pcodec->audio_utils_handle = audio_utils; 02057 02058 return CODEC_ERROR_NONE; 02059 } 02060 02061 /* --------------------------------------------------------------------------*/ 02069 /* --------------------------------------------------------------------------*/ 02070 int codec_release_audio_utils(codec_para_t *pcodec) 02071 { 02072 if (pcodec) { 02073 if(pcodec->audio_utils_handle>=0) 02074 codec_h_close(pcodec->audio_utils_handle); 02075 } 02076 02077 pcodec->audio_utils_handle = -1; 02078 02079 return CODEC_ERROR_NONE; 02080 } 02081 02082 /* --------------------------------------------------------------------------*/ 02090 /* --------------------------------------------------------------------------*/ 02091 int codec_set_audio_resample_ena(codec_para_t *pcodec, unsigned long mode) 02092 { 02093 return codec_h_control(pcodec->audio_utils_handle, AMAUDIO_IOC_SET_RESAMPLE_ENA, mode); 02094 } 02095 02096 /* --------------------------------------------------------------------------*/ 02104 /* --------------------------------------------------------------------------*/ 02105 int codec_get_audio_resample_ena(codec_para_t *pcodec) 02106 { 02107 unsigned long audio_resample_ena; 02108 int ret; 02109 ret = codec_h_control(pcodec->audio_utils_handle, AMAUDIO_IOC_GET_RESAMPLE_ENA, &audio_resample_ena); 02110 if (ret < 0) { 02111 return system_error_to_codec_error(ret); 02112 } else { 02113 return audio_resample_ena; 02114 } 02115 } 02116 02117 /* --------------------------------------------------------------------------*/ 02125 /* --------------------------------------------------------------------------*/ 02126 int codec_set_audio_resample_type(codec_para_t *pcodec, unsigned long type) 02127 { 02128 return codec_h_control(pcodec->audio_utils_handle, AMAUDIO_IOC_SET_RESAMPLE_TYPE, type); 02129 } 02130 02131 /* --------------------------------------------------------------------------*/ 02139 /* --------------------------------------------------------------------------*/ 02140 int codec_set_video_delay_limited_ms(codec_para_t *pcodec,int delay_ms) 02141 { 02142 return codec_h_control(pcodec->handle, AMSTREAM_IOC_SET_VIDEO_DELAY_LIMIT_MS, delay_ms); 02143 } 02144 /* --------------------------------------------------------------------------*/ 02152 /* --------------------------------------------------------------------------*/ 02153 int codec_get_video_delay_limited_ms(codec_para_t *pcodec,int *delay_ms) 02154 { 02155 return codec_h_control(pcodec->handle, AMSTREAM_IOC_GET_VIDEO_DELAY_LIMIT_MS, delay_ms); 02156 } 02157 02158 02159 /* --------------------------------------------------------------------------*/ 02167 /* --------------------------------------------------------------------------*/ 02168 int codec_set_audio_delay_limited_ms(codec_para_t *pcodec,int delay_ms) 02169 { 02170 return codec_h_control(pcodec->handle, AMSTREAM_IOC_SET_AUDIO_DELAY_LIMIT_MS, delay_ms); 02171 } 02172 02173 /* --------------------------------------------------------------------------*/ 02181 /* --------------------------------------------------------------------------*/ 02182 int codec_get_audio_delay_limited_ms(codec_para_t *pcodec,int *delay_ms) 02183 { 02184 return codec_h_control(pcodec->handle, AMSTREAM_IOC_GET_AUDIO_DELAY_LIMIT_MS, delay_ms); 02185 } 02186 02187 /* --------------------------------------------------------------------------*/ 02195 /* --------------------------------------------------------------------------*/ 02196 int codec_get_audio_cur_delay_ms(codec_para_t *pcodec,int *delay_ms) 02197 { 02198 int abuf_delay = 0; 02199 int adec_delay = 0; 02200 int ret = 0; 02201 ret = codec_h_control(pcodec->handle, AMSTREAM_IOC_GET_AUDIO_CUR_DELAY_MS, &abuf_delay); 02202 if(ret < 0){ 02203 CODEC_PRINT("[%s]ioctl failed %d\n", __FUNCTION__, ret); 02204 return -1; 02205 } 02206 if (pcodec->has_audio) { 02207 adec_delay = audio_get_decoded_pcm_delay(pcodec->adec_priv); 02208 if(adec_delay < 0) 02209 adec_delay = 0; 02210 } 02211 *delay_ms = abuf_delay+adec_delay; 02212 return ret; 02213 } 02214 02215 02216 02217 /* --------------------------------------------------------------------------*/ 02225 /* --------------------------------------------------------------------------*/ 02226 int codec_get_video_cur_delay_ms(codec_para_t *pcodec,int *delay_ms) 02227 { 02228 return codec_h_control(pcodec->handle, AMSTREAM_IOC_GET_VIDEO_CUR_DELAY_MS, delay_ms); 02229 } 02230 02231 /* --------------------------------------------------------------------------*/ 02239 /* --------------------------------------------------------------------------*/ 02240 int codec_get_video_cur_bitrate(codec_para_t *pcodec,int *bitrate) 02241 { 02242 return codec_h_control(pcodec->handle, AMSTREAM_IOC_GET_VIDEO_AVG_BITRATE_BPS, bitrate); 02243 } 02244 02245 02246 /* --------------------------------------------------------------------------*/ 02254 /* --------------------------------------------------------------------------*/ 02255 int codec_get_audio_cur_bitrate(codec_para_t *pcodec,int *bitrate) 02256 { 02257 return codec_h_control(pcodec->handle, AMSTREAM_IOC_GET_AUDIO_AVG_BITRATE_BPS, bitrate); 02258 } 02259 02260 /* --------------------------------------------------------------------------*/ 02269 /* --------------------------------------------------------------------------*/ 02270 int codec_set_vsync_upint(codec_para_t *pcodec, unsigned int mode) 02271 { 02272 return codec_h_control(pcodec->cntl_handle, AMSTREAM_IOC_SET_VSYNC_UPINT, (unsigned long)mode); 02273 } 02274 int codec_set_drmmode(codec_para_t *pcodec, unsigned int setval) 02275 { 02276 return codec_h_control(pcodec->handle, AMSTREAM_IOC_SET_DRMMODE, setval); 02277 } 02278 02283 int codec_get_last_checkout_apts(codec_para_t* pcodec, unsigned long *apts) 02284 { 02285 return codec_h_control(pcodec->handle, AMSTREAM_IOC_GET_LAST_CHECKOUT_APTS, apts); 02286 } 02287 02288 int codec_get_last_checkin_apts(codec_para_t* pcodec, unsigned long* apts) 02289 { 02290 return codec_h_control(pcodec->handle, AMSTREAM_IOC_GET_LAST_CHECKIN_APTS, apts); 02291 } 02292 02301 int codec_get_pcm_level(codec_para_t* pcodec, unsigned int* level) 02302 { 02303 return audio_get_pcm_level(pcodec->adec_priv); 02304 } 02305 02306 int codec_set_skip_bytes(codec_para_t* pcodec, unsigned int bytes) 02307 { 02308 return audio_set_skip_bytes(pcodec->adec_priv); 02309 } 02310 02311 int codec_get_dsp_apts(codec_para_t* pcodec, unsigned int * apts) 02312 { 02313 return audio_get_pts(pcodec->adec_priv, apts); 02314 } 02315 02316 /* --------------------------------------------------------------------------*/ 02324 /* --------------------------------------------------------------------------*/ 02325 int codec_get_cntl_vpts(codec_para_t *pcodec) 02326 { 02327 int cntl_vpts, r; 02328 02329 if (pcodec->cntl_handle == 0) { 02330 CODEC_PRINT("no control handler\n"); 02331 return 0; 02332 } 02333 02334 r = codec_h_control(pcodec->cntl_handle, AMSTREAM_IOC_GET_TRICK_VPTS, (unsigned long)&cntl_vpts); 02335 if (r < 0) { 02336 return system_error_to_codec_error(r); 02337 } else { 02338 return cntl_vpts; 02339 } 02340 } 02341 02342 /* --------------------------------------------------------------------------*/ 02351 /* --------------------------------------------------------------------------*/ 02352 int codec_disalbe_slowsync(codec_para_t *pcodec, int disable_slowsync) 02353 { 02354 int cntl_vpts, r; 02355 02356 if (pcodec->cntl_handle == 0) { 02357 CODEC_PRINT("no control handler\n"); 02358 return 0; 02359 } 02360 02361 r = codec_h_control(pcodec->cntl_handle, AMSTREAM_IOC_DISABLE_SLOW_SYNC, (unsigned long)disable_slowsync); 02362 if (r < 0) { 02363 return system_error_to_codec_error(r); 02364 } else { 02365 return 0; 02366 } 02367 } 02368
Generated on Tue Dec 2 2014 21:58:54 for amcodecMy Project by
1.7.6.1