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 
00027 #define SUBTITLE_EVENT
00028 #define TS_PACKET_SIZE 188
00029 
00030 /* --------------------------------------------------------------------------*/
00038 /* --------------------------------------------------------------------------*/
00039 static int codec_change_buf_size(codec_para_t *pcodec)
00040 {
00041     int r;
00042     if (pcodec->abuf_size > 0) {
00043         r = codec_h_control(pcodec->handle, AMSTREAM_IOC_AB_SIZE, pcodec->abuf_size);
00044         if (r < 0) {
00045             return system_error_to_codec_error(r);
00046         }
00047     }
00048     if (pcodec->vbuf_size > 0) {
00049         r = codec_h_control(pcodec->handle, AMSTREAM_IOC_VB_SIZE, pcodec->vbuf_size);
00050         if (r < 0) {
00051             return system_error_to_codec_error(r);
00052         }
00053     }
00054     return CODEC_ERROR_NONE;
00055 }
00056 /* --------------------------------------------------------------------------*/
00064 /* --------------------------------------------------------------------------*/
00065 static  int set_video_format(codec_para_t *pcodec)
00066 {
00067     int format = pcodec->video_type;
00068     int r;
00069 
00070     if (format < 0 || format > VFORMAT_MAX) {
00071         return -CODEC_ERROR_VIDEO_TYPE_UNKNOW;
00072     }
00073 
00074     r = codec_h_control(pcodec->handle, AMSTREAM_IOC_VFORMAT, format);
00075     if (pcodec->video_pid >= 0) {
00076         r = codec_h_control(pcodec->handle, AMSTREAM_IOC_VID, pcodec->video_pid);
00077         if (r < 0) {
00078             return system_error_to_codec_error(r);
00079         }
00080     }
00081     if (r < 0) {
00082         return system_error_to_codec_error(r);
00083     }
00084     return 0;
00085 }
00086 
00087 /* --------------------------------------------------------------------------*/
00095 /* --------------------------------------------------------------------------*/
00096 static  int set_video_codec_info(codec_para_t *pcodec)
00097 {
00098     dec_sysinfo_t am_sysinfo = pcodec->am_sysinfo;
00099     int r;
00100 
00101     r = codec_h_control(pcodec->handle, AMSTREAM_IOC_SYSINFO, (unsigned long)&am_sysinfo);
00102     if (r < 0) {
00103         return system_error_to_codec_error(r);
00104     }
00105     return 0;
00106 }
00107 /* --------------------------------------------------------------------------*/
00115 /* --------------------------------------------------------------------------*/
00116 static  int set_audio_format(codec_para_t *pcodec)
00117 {
00118     int format = pcodec->audio_type;
00119     int r;
00120     int codec_r;
00121 
00122     if (format < 0 || format > AFORMAT_MAX) {
00123         return -CODEC_ERROR_AUDIO_TYPE_UNKNOW;
00124     }
00125 
00126     r = codec_h_control(pcodec->handle, AMSTREAM_IOC_AFORMAT, format);
00127     if (r < 0) {
00128         codec_r = system_error_to_codec_error(r);
00129         print_error_msg(codec_r, __FUNCTION__, __LINE__);
00130         return codec_r;
00131     }
00132     if (pcodec->audio_pid >= 0) {
00133         r = codec_h_control(pcodec->handle, AMSTREAM_IOC_AID, pcodec->audio_pid);
00134         if (r < 0) {
00135             codec_r = system_error_to_codec_error(r);
00136             print_error_msg(codec_r, __FUNCTION__, __LINE__);
00137             return codec_r;
00138         }
00139     }
00140     if (pcodec->audio_samplerate > 0) {
00141         r = codec_h_control(pcodec->handle, AMSTREAM_IOC_SAMPLERATE, pcodec->audio_samplerate);
00142         if (r < 0) {
00143             codec_r = system_error_to_codec_error(r);
00144             print_error_msg(codec_r, __FUNCTION__, __LINE__);
00145             return codec_r;
00146         }
00147     }
00148     if (pcodec->audio_channels > 0) {
00149         r = codec_h_control(pcodec->handle, AMSTREAM_IOC_ACHANNEL, pcodec->audio_channels);
00150         if (r < 0) {
00151             codec_r = system_error_to_codec_error(r);
00152             print_error_msg(codec_r, __FUNCTION__, __LINE__);
00153             return codec_r;
00154         }
00155     }
00156     return 0;
00157 }
00158 
00159 /* --------------------------------------------------------------------------*/
00167 /* --------------------------------------------------------------------------*/
00168 static int set_audio_info(codec_para_t *pcodec)
00169 {
00170     int r;
00171     int codec_r;
00172     audio_info_t *audio_info = &pcodec->audio_info;
00173     CODEC_PRINT("set_audio_info\n");
00174     r = codec_h_control(pcodec->handle, AMSTREAM_IOC_AUDIO_INFO, audio_info);
00175     if (r < 0) {
00176         codec_r = system_error_to_codec_error(r);
00177         print_error_msg(codec_r, __FUNCTION__, __LINE__);
00178         return codec_r;
00179     }
00180     return 0;
00181 }
00182 
00183 /* --------------------------------------------------------------------------*/
00191 /* --------------------------------------------------------------------------*/
00192 static int set_sub_format(codec_para_t *pcodec)
00193 {
00194     int r;
00195 
00196     if (pcodec->sub_pid >= 0) {
00197         r = codec_h_control(pcodec->handle, AMSTREAM_IOC_SID, pcodec->sub_pid);
00198         if (r < 0) {
00199             return system_error_to_codec_error(r);
00200         }
00201 
00202         r = codec_h_control(pcodec->handle, AMSTREAM_IOC_SUB_TYPE, pcodec->sub_type);
00203         if (r < 0) {
00204             return system_error_to_codec_error(r);
00205         }
00206     }
00207 
00208     return 0;
00209 }
00210 
00211 /* --------------------------------------------------------------------------*/
00219 /* --------------------------------------------------------------------------*/
00220 static int set_ts_skip_byte(codec_para_t *pcodec)
00221 {
00222     int r, skip_byte;
00223 
00224     skip_byte = pcodec->packet_size - TS_PACKET_SIZE;
00225 
00226     if (skip_byte < 0) {
00227         skip_byte = 0;
00228     }
00229 
00230     r = codec_h_control(pcodec->handle, AMSTREAM_IOC_TS_SKIPBYTE, skip_byte);
00231     if (r < 0) {
00232         return system_error_to_codec_error(r);
00233     }
00234 
00235     return 0;
00236 }
00237 
00238 /* --------------------------------------------------------------------------*/
00246 /* --------------------------------------------------------------------------*/
00247 static inline int codec_video_es_init(codec_para_t *pcodec)
00248 {
00249     CODEC_HANDLE handle;
00250     int r;
00251     int codec_r;
00252     int flags = O_WRONLY;
00253     if (!pcodec->has_video) {
00254         return CODEC_ERROR_NONE;
00255     }
00256 
00257     flags |= pcodec->noblock ? O_NONBLOCK : 0;
00258     handle = codec_h_open(CODEC_VIDEO_ES_DEVICE, flags);
00259     if (handle < 0) {
00260         codec_r = system_error_to_codec_error(handle);
00261         print_error_msg(codec_r, __FUNCTION__, __LINE__);
00262         return CODEC_OPEN_HANDLE_FAILED;
00263     }
00264     pcodec->handle = handle;
00265     r = set_video_format(pcodec);
00266     if (r < 0) {
00267         codec_h_close(handle);
00268         codec_r = system_error_to_codec_error(r);
00269         print_error_msg(codec_r, __FUNCTION__, __LINE__);
00270         return codec_r;
00271     }
00272     r = set_video_codec_info(pcodec);
00273     if (r < 0) {
00274         codec_h_close(handle);
00275         codec_r = system_error_to_codec_error(r);
00276         print_error_msg(codec_r, __FUNCTION__, __LINE__);
00277         return codec_r;
00278     }
00279     return CODEC_ERROR_NONE;
00280 }
00281 
00282 
00283 /* --------------------------------------------------------------------------*/
00291 /* --------------------------------------------------------------------------*/
00292 static inline int codec_audio_es_init(codec_para_t *pcodec)
00293 {
00294     CODEC_HANDLE handle;
00295     int r;
00296     int flags = O_WRONLY;
00297     int codec_r;
00298     if (!pcodec->has_audio) {
00299         return CODEC_ERROR_NONE;
00300     }
00301 
00302     flags |= pcodec->noblock ? O_NONBLOCK : 0;
00303     handle = codec_h_open(CODEC_AUDIO_ES_DEVICE, flags);
00304     if (handle < 0) {
00305         codec_r = system_error_to_codec_error(handle);
00306         print_error_msg(codec_r, __FUNCTION__, __LINE__);
00307         return CODEC_OPEN_HANDLE_FAILED;
00308     }
00309     pcodec->handle = handle;
00310     r = set_audio_format(pcodec);
00311     if (r < 0) {
00312         codec_h_close(handle);
00313         codec_r = system_error_to_codec_error(r);
00314         print_error_msg(codec_r, __FUNCTION__, __LINE__);
00315         return codec_r;
00316     }
00317 
00318     if ((pcodec->audio_type == AFORMAT_ADPCM) || (pcodec->audio_type == AFORMAT_WMAPRO) || (pcodec->audio_type == AFORMAT_WMA) || (pcodec->audio_type == AFORMAT_PCM_S16BE)
00319         || (pcodec->audio_type == AFORMAT_PCM_S16LE) || (pcodec->audio_type == AFORMAT_PCM_U8)) {
00320         r = set_audio_info(pcodec);
00321         if (r < 0) {
00322             codec_h_close(handle);
00323             codec_r = system_error_to_codec_error(r);
00324             print_error_msg(codec_r, __FUNCTION__, __LINE__);
00325             return codec_r;
00326         }
00327     }
00328 
00329     return CODEC_ERROR_NONE;
00330 }
00331 
00332 /* --------------------------------------------------------------------------*/
00340 /* --------------------------------------------------------------------------*/
00341 static inline int codec_sub_es_init(codec_para_t *pcodec)
00342 {
00343 #ifdef SUBTITLE_EVENT
00344     int r, codec_r;
00345 
00346     if (pcodec->has_sub) {
00347         r = codec_init_sub(pcodec);
00348         if (r < 0) {
00349             codec_r = system_error_to_codec_error(r);
00350             print_error_msg(codec_r, __FUNCTION__, __LINE__);
00351             return CODEC_OPEN_HANDLE_FAILED;
00352         }
00353         pcodec->handle = pcodec->sub_handle;
00354 
00355         pcodec->sub_pid = 0xffff; // for es, sub id is identified for es parser
00356         r = set_sub_format(pcodec);
00357         if (r < 0) {
00358             codec_r = system_error_to_codec_error(r);
00359             print_error_msg(codec_r, __FUNCTION__, __LINE__);
00360             return codec_r;
00361         }
00362 
00363     }
00364 
00365 #endif
00366 
00367     return CODEC_ERROR_NONE;
00368 }
00369 
00370 /* --------------------------------------------------------------------------*/
00378 /* --------------------------------------------------------------------------*/
00379 static inline int codec_ps_init(codec_para_t *pcodec)
00380 {
00381     CODEC_HANDLE handle;
00382     int r;
00383     int flags = O_WRONLY;
00384     int codec_r;
00385     if (!((pcodec->has_video && IS_VALID_PID(pcodec->video_pid)) ||
00386           (pcodec->has_audio && IS_VALID_PID(pcodec->audio_pid)))) {
00387         return -CODEC_ERROR_PARAMETER;
00388     }
00389 
00390     flags |= pcodec->noblock ? O_NONBLOCK : 0;
00391     handle = codec_h_open(CODEC_PS_DEVICE, flags);
00392     if (handle < 0) {
00393         codec_r = system_error_to_codec_error(handle);
00394         print_error_msg(codec_r, __FUNCTION__, __LINE__);
00395         return CODEC_OPEN_HANDLE_FAILED;
00396     }
00397     pcodec->handle = handle;
00398     if (pcodec->has_video) {
00399         r = set_video_format(pcodec);
00400         if (r < 0) {
00401             goto error1;
00402         }
00403         if (pcodec->video_type == VFORMAT_H264) {
00404             r = set_video_codec_info(pcodec);
00405             if (r < 0) {
00406                 /*codec_h_close(handle);
00407                 codec_r = system_error_to_codec_error(r);
00408                 print_error_msg(codec_r, __FUNCTION__, __LINE__);
00409                 return codec_r; */
00410                 goto error1;
00411             }
00412         }
00413     }
00414     if (pcodec->has_audio) {
00415         r = set_audio_format(pcodec);
00416         if (r < 0) {
00417             goto error1;
00418         }
00419 
00420         if ((pcodec->audio_type == AFORMAT_ADPCM) || (pcodec->audio_type == AFORMAT_WMA) || (pcodec->audio_type == AFORMAT_WMAPRO) || (pcodec->audio_type == AFORMAT_PCM_S16BE)
00421             || (pcodec->audio_type == AFORMAT_PCM_S16LE) || (pcodec->audio_type == AFORMAT_PCM_U8)
00422             || (pcodec->audio_type == AFORMAT_PCM_BLURAY)) {
00423             r = set_audio_info(pcodec);
00424             if (r < 0) {
00425                 goto error1;
00426             }
00427         }
00428     }
00429 #ifdef SUBTITLE_EVENT
00430     if (pcodec->has_sub) {
00431         r = set_sub_format(pcodec);
00432         if (r < 0) {
00433             goto error1;
00434         }
00435 
00436         r = codec_init_sub(pcodec);
00437         if (r < 0) {
00438             goto error1;
00439         }
00440     }
00441 #endif
00442 
00443     return CODEC_ERROR_NONE;
00444 error1:
00445     codec_h_close(handle);
00446     codec_r = system_error_to_codec_error(r);
00447     print_error_msg(codec_r, __FUNCTION__, __LINE__);
00448     return codec_r;
00449 
00450 }
00451 
00452 
00453 /* --------------------------------------------------------------------------*/
00461 /* --------------------------------------------------------------------------*/
00462 static inline int codec_ts_init(codec_para_t *pcodec)
00463 {
00464     CODEC_HANDLE handle;
00465     int r;
00466     int flags = O_WRONLY;
00467     int codec_r;
00468     if (!((pcodec->has_video && IS_VALID_PID(pcodec->video_pid)) ||
00469           (pcodec->has_audio && IS_VALID_PID(pcodec->audio_pid)))) {
00470         return -CODEC_ERROR_PARAMETER;
00471     }
00472 
00473     flags |= pcodec->noblock ? O_NONBLOCK : 0;
00474     handle = codec_h_open(CODEC_TS_DEVICE, flags);
00475     if (handle < 0) {
00476         codec_r = system_error_to_codec_error(handle);
00477         print_error_msg(codec_r, __FUNCTION__, __LINE__);
00478         return CODEC_OPEN_HANDLE_FAILED;
00479     }
00480     pcodec->handle = handle;
00481     if (pcodec->has_video) {
00482         r = set_video_format(pcodec);
00483         if (r < 0) {
00484             goto error1;
00485         }
00486         if ((pcodec->video_type == VFORMAT_H264) || (pcodec->video_type == VFORMAT_VC1)) {
00487             r = set_video_codec_info(pcodec);
00488             if (r < 0) {
00489                 codec_h_close(handle);
00490                 codec_r = system_error_to_codec_error(r);
00491                 print_error_msg(codec_r, __FUNCTION__, __LINE__);
00492                 return codec_r;
00493             }
00494         }
00495     }
00496     if (pcodec->has_audio) {
00497         r = set_audio_format(pcodec);
00498         if (r < 0) {
00499             goto error1;
00500         }
00501 
00502         if ((pcodec->audio_type == AFORMAT_ADPCM) || (pcodec->audio_type == AFORMAT_WMA) || (pcodec->audio_type == AFORMAT_WMAPRO) || (pcodec->audio_type == AFORMAT_PCM_S16BE)
00503             || (pcodec->audio_type == AFORMAT_PCM_S16LE) || (pcodec->audio_type == AFORMAT_PCM_U8)
00504             || (pcodec->audio_type == AFORMAT_PCM_BLURAY)) {
00505             r = set_audio_info(pcodec);
00506             if (r < 0) {
00507                 goto error1;
00508             }
00509         }
00510     }
00511 
00512     r = set_ts_skip_byte(pcodec);
00513     if (r < 0) {
00514         goto error1;
00515     }
00516 
00517 #ifdef SUBTITLE_EVENT
00518     if (pcodec->has_sub) {
00519         r = set_sub_format(pcodec);
00520         if (r < 0) {
00521             goto error1;
00522         }
00523 
00524         r = codec_init_sub(pcodec);
00525         if (r < 0) {
00526             goto error1;
00527         }
00528     }
00529 #endif
00530     return CODEC_ERROR_NONE;
00531 error1:
00532     codec_h_close(handle);
00533     codec_r = system_error_to_codec_error(r);
00534     print_error_msg(codec_r, __FUNCTION__, __LINE__);
00535     return codec_r;
00536 
00537 }
00538 
00539 /* --------------------------------------------------------------------------*/
00547 /* --------------------------------------------------------------------------*/
00548 static inline int codec_rm_init(codec_para_t *pcodec)
00549 {
00550     CODEC_HANDLE handle;
00551     int r;
00552     int flags = O_WRONLY;
00553     int codec_r;
00554     if (!((pcodec->has_video && IS_VALID_PID(pcodec->video_pid)) ||
00555           (pcodec->has_audio && IS_VALID_PID(pcodec->audio_pid)))) {
00556         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);
00557         return -CODEC_ERROR_PARAMETER;
00558     }
00559     flags |= pcodec->noblock ? O_NONBLOCK : 0;
00560     handle = codec_h_open(CODEC_RM_DEVICE, flags);
00561     if (handle < 0) {
00562         codec_r = system_error_to_codec_error(handle);
00563         print_error_msg(codec_r, __FUNCTION__, __LINE__);
00564         return CODEC_OPEN_HANDLE_FAILED;
00565     }
00566 
00567     pcodec->handle = handle;
00568     if (pcodec->has_video) {
00569         r = set_video_format(pcodec);
00570         if (r < 0) {
00571             goto error1;
00572         }
00573 
00574         r = set_video_codec_info(pcodec);
00575         if (r < 0) {
00576             goto error1;
00577         }
00578     }
00579     if (pcodec->has_audio) {
00580         r = set_audio_format(pcodec);
00581         if (r < 0) {
00582             goto error1;
00583         }
00584         r = set_audio_info(pcodec);
00585         if (r < 0) {
00586             goto error1;
00587         }
00588     }
00589     return CODEC_ERROR_NONE;
00590 
00591 error1:
00592     codec_h_close(handle);
00593     codec_r = system_error_to_codec_error(r);
00594     print_error_msg(codec_r, __FUNCTION__, __LINE__);
00595     return codec_r;
00596 }
00597 
00598 /* --------------------------------------------------------------------------*/
00606 /* --------------------------------------------------------------------------*/
00607 int codec_init(codec_para_t *pcodec)
00608 {
00609     int ret;
00610     //if(pcodec->has_audio)
00611     //  audio_stop();
00612     switch (pcodec->stream_type) {
00613     case STREAM_TYPE_ES_VIDEO:
00614         ret = codec_video_es_init(pcodec);
00615         break;
00616     case STREAM_TYPE_ES_AUDIO:
00617         ret = codec_audio_es_init(pcodec);
00618         break;
00619     case STREAM_TYPE_ES_SUB:
00620         ret = codec_sub_es_init(pcodec);
00621         break;
00622     case STREAM_TYPE_PS:
00623         ret = codec_ps_init(pcodec);
00624         break;
00625     case STREAM_TYPE_TS:
00626         ret = codec_ts_init(pcodec);
00627         break;
00628     case STREAM_TYPE_RM:
00629         ret = codec_rm_init(pcodec);
00630         break;
00631     case STREAM_TYPE_UNKNOW:
00632     default:
00633         return -CODEC_ERROR_STREAM_TYPE_UNKNOW;
00634     }
00635     if (ret != 0) {
00636         return ret;
00637     }
00638     ret = codec_change_buf_size(pcodec);
00639     if (ret != 0) {
00640         return -CODEC_ERROR_SET_BUFSIZE_FAILED;
00641     }
00642     ret = codec_h_control(pcodec->handle, AMSTREAM_IOC_PORT_INIT, 0);
00643     if (ret != 0) {
00644 
00645         return -CODEC_ERROR_INIT_FAILED;
00646     }
00647     if (pcodec->has_audio) {
00648         audio_start();
00649     }
00650     return ret;
00651 }
00652 
00653 /* --------------------------------------------------------------------------*/
00663 /* --------------------------------------------------------------------------*/
00664 int codec_write(codec_para_t *pcodec, void *buffer, int len)
00665 {
00666     return codec_h_write(pcodec->handle, buffer, len);
00667 }
00668 
00669 /* --------------------------------------------------------------------------*/
00679 /* --------------------------------------------------------------------------*/
00680 int codec_read(codec_para_t *pcodec, void *buffer, int len)
00681 {
00682     return codec_h_read(pcodec->handle, buffer, len);
00683 }
00684 
00685 /* --------------------------------------------------------------------------*/
00693 /* --------------------------------------------------------------------------*/
00694 int codec_close(codec_para_t *pcodec)
00695 {
00696     if (pcodec->has_audio) {
00697         audio_stop();
00698     }
00699 #ifdef SUBTITLE_EVENT
00700     if (pcodec->has_sub && pcodec->sub_handle >= 0) {
00701         codec_close_sub_fd(pcodec->sub_handle);
00702     }
00703 #endif
00704     return codec_h_close(pcodec->handle);
00705 }
00706 
00707 /* --------------------------------------------------------------------------*/
00713 /* --------------------------------------------------------------------------*/
00714 void codec_close_audio(codec_para_t *pcodec)
00715 {
00716     if (pcodec) {
00717         pcodec->has_audio = 0;
00718     }
00719     audio_stop();
00720     return;
00721 }
00722 
00723 /* --------------------------------------------------------------------------*/
00730 /* --------------------------------------------------------------------------*/
00731 void codec_resume_audio(codec_para_t *pcodec, unsigned int orig)
00732 {
00733     pcodec->has_audio = orig;
00734     if (pcodec->has_audio) {
00735         audio_start();
00736     }
00737     return;
00738 }
00739 
00740 /* --------------------------------------------------------------------------*/
00749 /* --------------------------------------------------------------------------*/
00750 int codec_checkin_pts(codec_para_t *pcodec, unsigned long pts)
00751 {
00752     //CODEC_PRINT("[%s:%d]pts=%x(%d)\n",__FUNCTION__,__LINE__,pts,pts/90000);
00753     return codec_h_control(pcodec->handle, AMSTREAM_IOC_TSTAMP, pts);
00754 }
00755 
00756 /* --------------------------------------------------------------------------*/
00765 /* --------------------------------------------------------------------------*/
00766 int codec_get_vbuf_state(codec_para_t *p, struct buf_status *buf)
00767 {
00768     int r;
00769     struct am_io_param am_io;
00770     r = codec_h_control(p->handle, AMSTREAM_IOC_VB_STATUS, (unsigned long)&am_io);
00771     memcpy(buf, &am_io.status, sizeof(*buf));
00772     return system_error_to_codec_error(r);
00773 }
00774 /* --------------------------------------------------------------------------*/
00783 /* --------------------------------------------------------------------------*/
00784 int codec_get_abuf_state(codec_para_t *p, struct buf_status *buf)
00785 {
00786     int r;
00787     struct am_io_param am_io;
00788     r = codec_h_control(p->handle, AMSTREAM_IOC_AB_STATUS, (unsigned long)&am_io);
00789     memcpy(buf, &am_io.status, sizeof(*buf));
00790     return system_error_to_codec_error(r);
00791 }
00792 
00793 /* --------------------------------------------------------------------------*/
00802 /* --------------------------------------------------------------------------*/
00803 int codec_get_vdec_state(codec_para_t *p, struct vdec_status *vdec)
00804 {
00805     int r;
00806     struct am_io_param am_io;
00807     r = codec_h_control(p->handle, AMSTREAM_IOC_VDECSTAT, (unsigned long)&am_io);
00808     if (r < 0) {
00809         CODEC_PRINT("[codec_get_vdec_state]error[%d]: %s\n", r, codec_error_msg(system_error_to_codec_error(r)));
00810     }
00811     memcpy(vdec, &am_io.vstatus, sizeof(*vdec));
00812     return system_error_to_codec_error(r);
00813 }
00814 
00815 /* --------------------------------------------------------------------------*/
00824 /* --------------------------------------------------------------------------*/
00825 int codec_get_adec_state(codec_para_t *p, struct adec_status *adec)
00826 {
00827     int r;
00828     struct am_io_param am_io;
00829     r = codec_h_control(p->handle, AMSTREAM_IOC_ADECSTAT, (unsigned long)&am_io);
00830     memcpy(adec, &am_io.astatus, sizeof(*adec));
00831     return system_error_to_codec_error(r);
00832 }
00833 
00834 /* --------------------------------------------------------------------------*/
00842 /* --------------------------------------------------------------------------*/
00843 static int video_pause(codec_para_t *p)
00844 {
00845     CODEC_PRINT("video_pause!\n");
00846     return codec_h_control(p->cntl_handle, AMSTREAM_IOC_VPAUSE, 1);
00847 }
00848 
00849 /* --------------------------------------------------------------------------*/
00857 /* --------------------------------------------------------------------------*/
00858 static int video_resume(codec_para_t *p)
00859 {
00860     CODEC_PRINT("video_resume!\n");
00861     return codec_h_control(p->cntl_handle, AMSTREAM_IOC_VPAUSE, 0);
00862 }
00863 
00864 /* --------------------------------------------------------------------------*/
00872 /* --------------------------------------------------------------------------*/
00873 int codec_pause(codec_para_t *p)
00874 {
00875     int ret = CODEC_ERROR_NONE;
00876     if (p) {
00877         CODEC_PRINT("[codec_pause]p->has_audio=%d\n", p->has_audio);
00878         if (p->has_audio) {
00879             audio_pause();
00880         } else {
00881             ret = video_pause(p);
00882         }
00883     } else {
00884         ret = CODEC_ERROR_PARAMETER;
00885     }
00886     return ret;
00887 }
00888 /* --------------------------------------------------------------------------*/
00896 /* --------------------------------------------------------------------------*/
00897 int codec_resume(codec_para_t *p)
00898 {
00899     int ret = CODEC_ERROR_NONE;
00900     if (p) {
00901         CODEC_PRINT("[codec_resume]p->has_audio=%d\n", p->has_audio);
00902         if (p->has_audio) {
00903             audio_resume();
00904         } else {
00905             ret = video_resume(p);
00906         }
00907     } else {
00908         ret = CODEC_ERROR_PARAMETER;
00909     }
00910     return ret;
00911 }
00912 
00913 /* --------------------------------------------------------------------------*/
00921 /* --------------------------------------------------------------------------*/
00922 int codec_reset(codec_para_t *p)
00923 {
00924     int ret;
00925     ret = codec_close(p);
00926     if (ret != 0) {
00927         return ret;
00928     }
00929     ret = codec_init(p);
00930     CODEC_PRINT("[%s:%d]ret=%x\n", __FUNCTION__, __LINE__, ret);
00931     return system_error_to_codec_error(ret);
00932 }
00933 
00934 /* --------------------------------------------------------------------------*/
00942 /* --------------------------------------------------------------------------*/
00943 int codec_init_sub(codec_para_t *pcodec)
00944 {
00945     CODEC_HANDLE sub_handle;
00946     int flags = O_WRONLY;
00947     flags |= pcodec->noblock ? O_NONBLOCK : 0;
00948     sub_handle = codec_h_open(CODEC_SUB_DEVICE, flags);
00949     if (sub_handle < 0) {
00950         CODEC_PRINT("get %s failed\n", CODEC_SUB_DEVICE);
00951         return system_error_to_codec_error(sub_handle);
00952     }
00953 
00954     pcodec->sub_handle = sub_handle;
00955     return CODEC_ERROR_NONE;
00956 }
00957 
00958 /* --------------------------------------------------------------------------*/
00964 /* --------------------------------------------------------------------------*/
00965 int codec_open_sub_read(void)
00966 {
00967     CODEC_HANDLE sub_handle;
00968 
00969     sub_handle = codec_h_open_rd(CODEC_SUB_READ_DEVICE);
00970     if (sub_handle < 0) {
00971         CODEC_PRINT("get %s failed\n", CODEC_SUB_READ_DEVICE);
00972         return system_error_to_codec_error(sub_handle);
00973     }
00974 
00975     return sub_handle;
00976 }
00977 
00978 /* --------------------------------------------------------------------------*/
00986 /* --------------------------------------------------------------------------*/
00987 int codec_close_sub(codec_para_t *pcodec)
00988 {
00989     if (pcodec) {
00990         return codec_h_close(pcodec->sub_handle);
00991     }
00992     return CODEC_ERROR_NONE;
00993 }
00994 
00995 /* --------------------------------------------------------------------------*/
01003 /* --------------------------------------------------------------------------*/
01004 int codec_close_sub_fd(CODEC_HANDLE sub_fd)
01005 {
01006     return codec_h_close(sub_fd);
01007 }
01008 
01009 /* --------------------------------------------------------------------------*/
01017 /* --------------------------------------------------------------------------*/
01018 int codec_poll_sub(codec_para_t *pcodec)
01019 {
01020     struct pollfd sub_poll_fd[1];
01021 
01022     if (pcodec->sub_handle == 0) {
01023         return 0;
01024     }
01025 
01026     sub_poll_fd[0].fd = pcodec->sub_handle;
01027     sub_poll_fd[0].events = POLLOUT;
01028 
01029     return poll(sub_poll_fd, 1, 10);
01030 }
01031 
01032 /* --------------------------------------------------------------------------*/
01041 /* --------------------------------------------------------------------------*/
01042 int codec_poll_sub_fd(CODEC_HANDLE sub_fd, int timeout)
01043 {
01044     struct pollfd sub_poll_fd[1];
01045 
01046     if (sub_fd <= 0) {
01047         return 0;
01048     }
01049 
01050     sub_poll_fd[0].fd = sub_fd;
01051     sub_poll_fd[0].events = POLLOUT;
01052 
01053     return poll(sub_poll_fd, 1, timeout);
01054 }
01055 
01056 /* --------------------------------------------------------------------------*/
01064 /* --------------------------------------------------------------------------*/
01065 int codec_get_sub_size(codec_para_t *pcodec)
01066 {
01067     int sub_size, r;
01068 
01069     if (pcodec->sub_handle == 0) {
01070         CODEC_PRINT("no control handler\n");
01071         return 0;
01072     }
01073 
01074     r = codec_h_control(pcodec->sub_handle, AMSTREAM_IOC_SUB_LENGTH, (unsigned long)&sub_size);
01075     if (r < 0) {
01076         return system_error_to_codec_error(r);
01077     } else {
01078         return sub_size;
01079     }
01080 }
01081 
01082 /* --------------------------------------------------------------------------*/
01090 /* --------------------------------------------------------------------------*/
01091 int codec_get_sub_size_fd(CODEC_HANDLE sub_fd)
01092 {
01093     int sub_size, r;
01094 
01095     if (sub_fd <= 0) {
01096         CODEC_PRINT("no sub handler\n");
01097         return 0;
01098     }
01099 
01100     r = codec_h_control(sub_fd, AMSTREAM_IOC_SUB_LENGTH, (unsigned long)&sub_size);
01101     if (r < 0) {
01102         return system_error_to_codec_error(r);
01103     } else {
01104         return sub_size;
01105     }
01106 }
01107 
01108 /* --------------------------------------------------------------------------*/
01118 /* --------------------------------------------------------------------------*/
01119 int codec_read_sub_data(codec_para_t *pcodec, char *buf, unsigned int length)
01120 {
01121     int data_size = length, r, read_done = 0;
01122 
01123     if (pcodec->sub_handle == 0) {
01124         CODEC_PRINT("no control handler\n");
01125         return 0;
01126     }
01127 
01128     while (data_size) {
01129         r = codec_h_read(pcodec->sub_handle, buf + read_done, data_size);
01130         if (r < 0) {
01131             return system_error_to_codec_error(r);
01132         } else {
01133             data_size -= r;
01134             read_done += r;
01135         }
01136     }
01137 
01138     return 0;
01139 }
01140 
01141 /* --------------------------------------------------------------------------*/
01151 /* --------------------------------------------------------------------------*/
01152 int codec_read_sub_data_fd(CODEC_HANDLE sub_fd, char *buf, unsigned int length)
01153 {
01154     int data_size = length, r, read_done = 0;
01155 
01156     if (sub_fd <= 0) {
01157         CODEC_PRINT("no sub handler\n");
01158         return 0;
01159     }
01160 
01161     while (data_size) {
01162         r = codec_h_read(sub_fd, buf + read_done, data_size);
01163         if (r < 0) {
01164             return system_error_to_codec_error(r);
01165         } else {
01166             data_size -= r;
01167             read_done += r;
01168         }
01169     }
01170 
01171     return 0;
01172 }
01173 
01174 /* --------------------------------------------------------------------------*/
01184 /* --------------------------------------------------------------------------*/
01185 int codec_write_sub_data(codec_para_t *pcodec, char *buf, unsigned int length)
01186 {
01187     if (pcodec->sub_handle == 0) {
01188         CODEC_PRINT("no control handler\n");
01189         return 0;
01190     }
01191 
01192     return codec_h_write(pcodec->sub_handle, buf, length);
01193 }
01194 
01195 /* --------------------------------------------------------------------------*/
01203 /* --------------------------------------------------------------------------*/
01204 int codec_init_cntl(codec_para_t *pcodec)
01205 {
01206     CODEC_HANDLE cntl;
01207 
01208     cntl = codec_h_open(CODEC_CNTL_DEVICE, O_WRONLY);
01209     if (cntl < 0) {
01210         CODEC_PRINT("get %s failed\n", CODEC_CNTL_DEVICE);
01211         return system_error_to_codec_error(cntl);
01212     }
01213 
01214     pcodec->cntl_handle = cntl;
01215     return CODEC_ERROR_NONE;
01216 }
01217 
01218 /* --------------------------------------------------------------------------*/
01226 /* --------------------------------------------------------------------------*/
01227 int codec_close_cntl(codec_para_t *pcodec)
01228 {
01229     if (pcodec) {
01230         return codec_h_close(pcodec->cntl_handle);
01231     }
01232     return CODEC_ERROR_NONE;
01233 }
01234 
01235 /* --------------------------------------------------------------------------*/
01243 /* --------------------------------------------------------------------------*/
01244 int codec_poll_cntl(codec_para_t *pcodec)
01245 {
01246     struct pollfd codec_poll_fd[1];
01247 
01248     if (pcodec->cntl_handle == 0) {
01249         return 0;
01250     }
01251 
01252     codec_poll_fd[0].fd = pcodec->cntl_handle;
01253     codec_poll_fd[0].events = POLLOUT;
01254 
01255     return poll(codec_poll_fd, 1, 10);
01256 }
01257 
01258 /* --------------------------------------------------------------------------*/
01266 /* --------------------------------------------------------------------------*/
01267 int codec_get_cntl_state(codec_para_t *pcodec)
01268 {
01269     int cntl_state, r;
01270 
01271     if (pcodec->cntl_handle == 0) {
01272         CODEC_PRINT("no control handler\n");
01273         return 0;
01274     }
01275 
01276     r = codec_h_control(pcodec->cntl_handle, AMSTREAM_IOC_TRICK_STAT, (unsigned long)&cntl_state);
01277     if (r < 0) {
01278         return system_error_to_codec_error(r);
01279     } else {
01280         return cntl_state;
01281     }
01282 }
01283 
01284 /* --------------------------------------------------------------------------*/
01293 /* --------------------------------------------------------------------------*/
01294 int codec_set_cntl_mode(codec_para_t *pcodec, unsigned int mode)
01295 {
01296     return codec_h_control(pcodec->cntl_handle, AMSTREAM_IOC_TRICKMODE, (unsigned long)mode);
01297 }
01298 
01299 /* --------------------------------------------------------------------------*/
01308 /* --------------------------------------------------------------------------*/
01309 int codec_set_cntl_avthresh(codec_para_t *pcodec, unsigned int avthresh)
01310 {
01311     return codec_h_control(pcodec->cntl_handle, AMSTREAM_IOC_AVTHRESH, (unsigned long)avthresh);
01312 }
01313 
01314 /* --------------------------------------------------------------------------*/
01324 /* --------------------------------------------------------------------------*/
01325 int codec_set_cntl_syncthresh(codec_para_t *pcodec, unsigned int syncthresh)
01326 {
01327     return codec_h_control(pcodec->cntl_handle, AMSTREAM_IOC_SYNCTHRESH, (unsigned long)syncthresh);
01328 }
01329 
01330 /* --------------------------------------------------------------------------*/
01338 /* --------------------------------------------------------------------------*/
01339 int codec_reset_audio(codec_para_t *pcodec)
01340 {
01341     return codec_h_control(pcodec->handle, AMSTREAM_IOC_AUDIO_RESET, 0);
01342 }
01343 
01344 /* --------------------------------------------------------------------------*/
01352 /* --------------------------------------------------------------------------*/
01353 int codec_reset_subtile(codec_para_t *pcodec)
01354 {
01355     return codec_h_control(pcodec->handle, AMSTREAM_IOC_SUB_RESET, 0);
01356 }
01357 
01358 /* --------------------------------------------------------------------------*/
01366 /* --------------------------------------------------------------------------*/
01367 int codec_set_audio_pid(codec_para_t *pcodec)
01368 {
01369     return codec_h_control(pcodec->handle, AMSTREAM_IOC_AID, pcodec->audio_pid);
01370 }
01371 
01372 /* --------------------------------------------------------------------------*/
01380 /* --------------------------------------------------------------------------*/
01381 int codec_set_sub_id(codec_para_t *pcodec)
01382 {
01383     return codec_h_control(pcodec->handle, AMSTREAM_IOC_SID, pcodec->sub_pid);
01384 }
01385 
01386 /* --------------------------------------------------------------------------*/
01394 /* --------------------------------------------------------------------------*/
01395 int codec_audio_reinit(codec_para_t *pcodec)
01396 {
01397     return set_audio_format(pcodec);
01398 }
01399 
01400 /* --------------------------------------------------------------------------*/
01408 /* --------------------------------------------------------------------------*/
01409 int codec_set_dec_reset(codec_para_t *pcodec)
01410 {
01411     return codec_h_control(pcodec->handle, AMSTREAM_IOC_SET_DEC_RESET, 0);
01412 }