关于我
 

xjpvictor's Blog
小老鼠，上灯台，两只耳朵竖起来

linux coreavc

05月 · 2011
各种折腾·archlinuxlinux

本文最后编辑于超过4125天以前，部分内容可能已经失效

上网本的cpu确实是太弱了。弱到电影稍微清楚点，分辨率高点就卡得没法看。想装一个coreavc进行解码。
在google project上有coreavc-for-linux，wiki上也很详细，基本上照着来就能安装了。先安装dshowserver和coreavc，然后是mplayer。
在安装dshowserver时，把trunk下载下来以后需要把/loader/dshow中的文件拷到/loader中，否则无法make过去。用wine安装CoreAVC Professional Edition-x.x.x_Setup.exe的时候先把~/.wine给删除了，不然会提示bad file descriptor。

安装mplayer的时候，需要用到/mplayer/dshowserver.patch，但是因为mplayer更新了，所以这个patch也需要更改。

  1. Index: libmpcodecs/vd.c

  2. ===================================================================

  3. --- libmpcodecs/vd.c.orig       2010-03-12 07:47:10.000000000 -0800

  4. +++ libmpcodecs/vd.c    2010-03-12 07:48:02.000000000 -0800

  5. @@ -43,6 +43,7 @@

  6. extern const vd_functions_t mpcodecs_vd_ffmpeg;

  7. extern const vd_functions_t mpcodecs_vd_theora;

  8. extern const vd_functions_t mpcodecs_vd_dshow;

  9. +extern const vd_functions_t mpcodecs_vd_dshowserver;

  10. extern const vd_functions_t mpcodecs_vd_dmo;

  11. extern const vd_functions_t mpcodecs_vd_vfw;

  12. extern const vd_functions_t mpcodecs_vd_vfwex;

  13. @@ -74,6 +75,7 @@

  14. #ifdef CONFIG_OGGTHEORA

  15. &mpcodecs;_vd_theora,

  16. #endif

  17. +        &mpcodecs;_vd_dshowserver,

  18. #ifdef CONFIG_WIN32DLL

  19. &mpcodecs;_vd_dshow,

  20. &mpcodecs;_vd_dmo,

  21. Index: Makefile

  22. ===================================================================

  23. --- Makefile.orig       2010-03-12 07:47:19.000000000 -0800

  24. +++ Makefile    2010-03-12 07:48:02.000000000 -0800

  25. @@ -20,6 +20,7 @@

  26. # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

  27. include config.mak

  28. +EXTRALIBS += -lrt

  29. 

  30. .SUFFIXES:

  31. 

  32. @@ -476,6 +518,7 @@

  33. stream/stream_mf.c

  34. stream/stream_null.c

  35. stream/url.c

  36. +              libmpcodecs/vd_dshowserver.c 

  37. sub/eosd.c

  38. 

  39. @@ -865,6 +868,7 @@

  40. libdvdread4/%: CFLAGS := -Ilibdvdread4 -D_GNU_SOURCE $(CFLAGS_LIBDVDCSS_DVDREAD) $(CFLAGS)

  41. 

  42. +libmpcodecs/%: CFLAGS := $(CFLAGS) -g -O0

  43. loader/%: CFLAGS += -fno-omit-frame-pointer $(CFLAGS_NO_OMIT_LEAF_FRAME_POINTER)

  44. #loader/%: CFLAGS += -Ddbg_printf=__vprintf -DTRACE=__vprintf -DDETAILED_OUT

  45. loader/win32%: CFLAGS += $(CFLAGS_STACKREALIGN)

  46. 

  47. Index: libmpcodecs/vd_dshowserver.c

  48. ===================================================================

  49. --- /dev/null   1970-01-01 00:00:00.000000000 +0000

  50. +++ libmpcodecs/vd_dshowserver.c        2010-03-12 07:56:33.000000000 -0800

  51. @@ -0,0 +1,295 @@

  52. +/*

  53. + * Copyright Alan Nisota 2006 - 2010

  54. + * To use this code, make sureyour codecs.conf file has been updated with this section:

  55. + * videocodec coreserve

  56. + *  info "CoreAVC DShowServer"

  57. + *  status untested

  58. + *  format 0x10000005

  59. + *  fourcc H264,h264

  60. + *  fourcc X264,x264

  61. + *  fourcc avc1,AVC1 AVC1

  62. + *  fourcc davc,DAVC

  63. + *  fourcc VSSH

  64. + *  driver dshowserver

  65. + *  dll "CoreAVCDecoder.ax"

  66. + *  guid 0x09571a4b, 0xf1fe, 0x4c60, 0x97, 0x60, 0xde, 0x6d, 0x31, 0x0c, 0x7c, 0x31

  67. + *  out YV12,IYUV,I420,YUY2

  68. + *

  69. + * Codec is very sensitive to the fourcc value.  As of 2009-08-30, mplayer incorrectly reports

  70. + * AVC1 as H264 when using lavf decoder, resulting in breakage.

  71. + * this can be corrected by using an alternate demuxer (-demuxer mov for example)

  72. + * or by adding this to the above file:

  73. + *  fourcc H264,h264 AVC1

  74. + * though that may break regular h264 playback

  75. + */

  76. +

  77. +#include 

  78. +#include 

  79. +#include 

  80. +#include mman.h><span>

  81. +#include 

  82. +

  83. +#include types.h><span>

  84. +#include 

  85. +#include stat.h><span>

  86. +#include 

  87. +#include 

  88. +#include wait.h><span>

  89. +

  90. +#include "config.h"

  91. +

  92. +#include "mp_msg.h"

  93. +

  94. +#include "vd_internal.h"

  95. +

  96. +struct vd_struct {

  97. +  union {

  98. +    uint32_t ret;

  99. +    uint32_t cmd;

  100. +  };

  101. +  uint32_t buflen;

  102. +  uint64_t pts;

  103. +  uint32_t unused[8];

  104. +} __attribute__((__packed__));

  105. +

  106. +enum {

  107. +  VD_END = 1,

  108. +  VD_DECODE = 2,

  109. +  VD_SEEK = 3,

  110. +  VD_HAS_BIH = 0x10000,

  111. +  VD_VERSION_MASK = 0xFFFF,

  112. +};

  113. +#include "timeout_sem.c"

  114. +

  115. +static vd_info_t info = {

  116. +       "DirectShowServer video codecs",

  117. +       "dshowserver",

  118. +       "Alan Nisota",

  119. +       "based on dshow",

  120. +       "win32 codecs"

  121. +};

  122. +

  123. +LIBVD_EXTERN(dshowserver)

  124. +typedef struct {

  125. +    int fd;

  126. +    void *mem;

  127. +    char *data;

  128. +    char *picture;

  129. +    int picsize;

  130. +    int pagesize;

  131. +    void *sem;

  132. +    struct vd_struct *vd;

  133. +} ds_mpi_t;

  134. +static ds_mpi_t *ds_mpi;

  135. +

  136. +// to set/get/query special features/parameters

  137. +static int control(sh_video_t *sh __attribute((unused)),int cmd,void* arg __attribute((unused)),...){

  138. +    switch(cmd){

  139. +    case VDCTRL_RESYNC_STREAM:

  140. +      printf("Seek nown");

  141. +      ds_mpi->vd->cmd = VD_SEEK; //'3' is cmd for seek

  142. +      timed_sempost(ds_mpi->sem);

  143. +      timed_semwait(ds_mpi->sem, 10);

  144. +      return CONTROL_TRUE;

  145. +    case VDCTRL_QUERY_MAX_PP_LEVEL:

  146. +       return 4;

  147. +    case VDCTRL_QUERY_UNSEEN_FRAMES:

  148. +       return 10;

  149. +

  150. +    }

  151. +    return CONTROL_UNKNOWN;

  152. +}

  153. +

  154. +static int my_system(const char *command)

  155. +{

  156. +    pid_t child = fork();

  157. +

  158. +    if (child < 0)

  159. +    {

  160. +        /* Fork failed */

  161. +        return child;

  162. +    }

  163. +    else if (child == 0)

  164. +    {

  165. +        /* Child */

  166. +        int i;

  167. +        /* Close all open file descriptors except stdout/stderr */

  168. +        for (i = sysconf(_SC_OPEN_MAX) - 1; i > 2; i--)

  169. +            close(i);

  170. +

  171. +        /* Attach stdin to /dev/null */

  172. +        /*

  173. +        close(0);

  174. +        int fd = open("/dev/null", O_RDONLY);

  175. +        dup2(fd, 0);

  176. +        if (fd != 0)

  177. +            close(fd);

  178. +        */

  179. +        /* Run command */

  180. +        execl("/bin/sh", "sh", "-c", command, NULL);

  181. +        _exit(0);

  182. +    }

  183. +    else

  184. +    {

  185. +        /* Parent */

  186. +        int status;

  187. +

  188. +        waitpid(child, &status;, 0);

  189. +        return status;

  190. +    }

  191. +

  192. +    return 1;

  193. +}

  194. +

  195. +// init driver

  196. +static int init(sh_video_t *sh){

  197. +    int ret;

  198. +    char cmd[255], shm[80], id[80];

  199. +    uint32_t out_fmt;

  200. +    int bpp, w, h;

  201. +    int extra = 0;

  202. +    int numpages = 10;

  203. +    int port = 0;

  204. +    int memsize;

  205. +

  206. +    init_twait();

  207. +    w = sh->disp_w; h = sh->disp_h;

  208. +    if(!mpcodecs_config_vo(sh,w,h,IMGFMT_YUY2)) return 0;

  209. +    out_fmt = sh->codec->outfmt[sh->outfmtidx];

  210. +    switch(out_fmt){

  211. +      case IMGFMT_YUY2:

  212. +      case IMGFMT_UYVY:

  213. +       bpp = 16; break;

  214. +      case IMGFMT_YV12:

  215. +      case IMGFMT_I420:

  216. +      case IMGFMT_IYUV:

  217. +       bpp = 12; break;

  218. +      case IMGFMT_YVU9:

  219. +        bpp = 9; break;

  220. +      default:

  221. +        bpp = 24; break;

  222. +    }

  223. +    sprintf(id, "%x", *(int *)pthread_self());

  224. +    snprintf(shm, 80, "/dshow_shm.%s", id);

  225. +

  226. +    ds_mpi = (ds_mpi_t *) malloc(sizeof(ds_mpi_t));

  227. +    ds_mpi->fd = shm_open(shm, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);

  228. +    ds_mpi->picsize =  w * h * bpp / 8;

  229. +    ds_mpi->pagesize = ds_mpi->picsize + 1024;

  230. +    memsize = sizeof(struct vd_struct) + w * h + ds_mpi->picsize + extra + ds_mpi->pagesize * numpages;

  231. +    ftruncate(ds_mpi->fd, memsize);

  232. +    ds_mpi->mem = mmap(NULL, memsize, PROT_READ | PROT_WRITE, MAP_SHARED, ds_mpi->fd, 0);

  233. +    if(ds_mpi->mem == MAP_FAILED) {

  234. +      perror("mmap");

  235. +      return 0;

  236. +    }

  237. +    memset((char *)ds_mpi->mem, 0, sizeof(struct vd_struct));

  238. +    if (extra)

  239. +      memset((char *)ds_mpi->mem + (memsize - extra), 0, extra);

  240. +    ds_mpi->vd = (struct vd_struct *)ds_mpi->mem;

  241. +    ds_mpi->data = ((char *)ds_mpi->mem) + sizeof(struct vd_struct);

  242. +    ds_mpi->picture = ds_mpi->data + w * h;

  243. +    if(sh->bih->biWidth && sh->bih->biHeight) {

  244. +      ds_mpi->vd->cmd |= VD_HAS_BIH; //Use embedded bih

  245. +      memcpy(ds_mpi->data, sh->bih, sh->bih->biSize);

  246. +    }

  247. +

  248. +    ds_mpi->sem = timed_seminit(DS_SOCKET, &port;, 1);

  249. +    //ds_mpi->sem = timed_seminit(DS_SEMAPHORE, id, 1);

  250. +

  251. +    snprintf(cmd, 255, "dshowserver --codec %s --size %dx%d "

  252. +             "--guid %08x-%04x-%04x-%02x%02x%02x%02x%02x%02x%02x%02x "

  253. +             "--fourc 0x%08x --bits %d --outfmt 0x%08x --pid %d --id %s "

  254. +             "--numpages %d --port %d %s&",

  255. +             sh->codec->dll, w, h,

  256. +             (unsigned int)sh->codec->guid.f1, sh->codec->guid.f2, sh->codec->guid.f3,

  257. +             sh->codec->guid.f4[0], sh->codec->guid.f4[1], sh->codec->guid.f4[2], sh->codec->guid.f4[3],

  258. +             sh->codec->guid.f4[4], sh->codec->guid.f4[5], sh->codec->guid.f4[6], sh->codec->guid.f4[7],

  259. +             (unsigned int)sh->format, bpp, out_fmt, getpid(), id, numpages, port, "");

  260. +    printf("%sn", cmd);

  261. +    my_system(cmd);

  262. +    ret = timed_semwait(ds_mpi->sem, 10);

  263. +    shm_unlink(shm);

  264. +    if(ret

  265. +      printf("DirectShow filter failed");

  266. +      return 0;

  267. +    } else {

  268. +      printf("Found DirectShow filter");

  269. +      return 1;

  270. +    }

  271. +}

  272. +

  273. +// uninit driver

  274. +static void uninit(sh_video_t *sh __attribute((unused))){

  275. +    if(ds_mpi) {

  276. +      printf("Destroying filter");

  277. +      ds_mpi->vd->cmd = VD_END; //'1' is cmd for terminating

  278. +      timed_sempost(ds_mpi->sem);

  279. +      close(ds_mpi->fd);

  280. +      timed_semdelete(ds_mpi->sem);

  281. +      free(ds_mpi);

  282. +      ds_mpi = NULL;

  283. +    }

  284. +}

  285. +

  286. +//mp_image_t* mpcodecs_get_image(sh_video_t *sh, int mp_imgtype, int mp_imgflag, int w, int h);

  287. +

  288. +// decode a frame

  289. +static mp_image_t* decode(sh_video_t *sh,void* data,int len,int flags){

  290. +   mp_image_t* mpi = NULL;

  291. +   int ret;

  292. +   unsigned char *t;

  293. +

  294. +   if(len

  295. +

  296. +   ds_mpi->vd->cmd = VD_DECODE; //'2' is cmd for decoding

  297. +   ds_mpi->vd->pts = (uint64_t)(1E9* (sh->num_buffered_pts ? sh->buffered_pts[0] : sh->pts));

  298. +   memcpy(ds_mpi->data, data, len);

  299. +   if (0) {

  300. +      static int count = 0;

  301. +      char f[80];

  302. +      FILE *fh;

  303. +

  304. +      if(count == 100)

  305. +          exit(1);

  306. +      sprintf(f, "/tmp/mplayer.%d", count++);

  307. +      fh = fopen(f, "w+");

  308. +      fwrite(data, len, 1, fh);

  309. +      fclose(fh);

  310. +   }

  311. +   ds_mpi->vd->buflen = len;

  312. +   timed_sempost(ds_mpi->sem);

  313. +   ret = timed_semwait(ds_mpi->sem, 10);

  314. +   if(flags&3) {

  315. +      // framedrop:

  316. +      return NULL;

  317. +   }

  318. +   //printf("len: %d, PTS (ret:%d,vd_ret:%d): %f -> %fn", len, ret, ds_mpi->vd->ret, sh->buffered_pts[0], (double)ds_mpi->vd->pts/1E9);

  319. +   //printf("PTS (%d): %f(%d) -> %dn", ds_mpi->vd->ret, sh->buffered_pts[0], pts-1, ds_mpi->vd->pts);

  320. +   if(ret == 1 && ds_mpi->vd->ret && ! (ds_mpi->vd->ret & (1<

  321. +     if(ds_mpi->vd->pts)

  322. +       sh->buffered_pts[0] = (double)ds_mpi->vd->pts/1E9;

  323. +       mpi=mpcodecs_get_image(sh, MP_IMGTYPE_EXPORT, MP_IMGFLAG_COMMON_PLANE|MP_IMGFLAG_COMMON_STRIDE,

  324. +                            sh->disp_w, sh->disp_h);

  325. +     if(ds_mpi->vd->ret & 0x02) {

  326. +       unsigned char page = ds_mpi->vd->ret >> 8;

  327. +       mpi->planes[0]=ds_mpi->picture + ds_mpi->picsize + page * ds_mpi->pagesize;

  328. +     } else {

  329. +       mpi->planes[0]=ds_mpi->picture;

  330. +     }

  331. +     if (mpi->flags&MP;_IMGFLAG_PLANAR) {

  332. +       mpi->stride[0] = mpi->width;

  333. +       mpi->stride[1] = mpi->stride[2] = mpi->width >> mpi->chroma_x_shift;

  334. +       mpi->planes[2] = mpi->planes[0] + mpi->stride[0] * mpi->height;

  335. +       mpi->planes[1] = mpi->planes[2] + (mpi->width >> mpi->chroma_x_shift) * (mpi->height >> mpi->chroma_y_shift);

  336. +       if (mpi->flags&MP;_IMGFLAG_SWAPPED) {

  337. +         t = mpi->planes[1];

  338. +         mpi->planes[1] = mpi->planes[2];

  339. +         mpi->planes[2] = t;

  340. +       }

  341. +     } else {

  342. +       mpi->stride[0]=mpi->bpp*mpi->width/8;

  343. +     }

  344. +   }

  345. +   return mpi;

  346. +}

  347. Index: libmpcodecs/timeout_sem.c

  348. ===================================================================

  349. --- /dev/null   1970-01-01 00:00:00.000000000 +0000

  350. +++ libmpcodecs/timeout_sem.c   2010-03-12 08:03:16.000000000 -0800

  351. @@ -0,0 +1,397 @@

  352. +#include 

  353. +#include 

  354. +#include 

  355. +#include 

  356. +#include 

  357. +#include 

  358. +

  359. +#ifndef __MINGW32__

  360. +  #include 

  361. +  #include in.h><span>

  362. +  #include socket.h><span>

  363. +  #include inet.h><span>

  364. +  #include wait.h><span>

  365. +

  366. +  #define DS_EINPROGRESS EINPROGRESS

  367. +  #define DS_ETIMEDOUT   ETIMEDOUT

  368. +  #define DS_EWOULDBLOCK EWOULDBLOCK

  369. +#else

  370. +  #define _WIN32_WINNT 0x0501

  371. +  #include 

  372. +  #include 

  373. +  #include 

  374. +

  375. +  #define DS_EINPROGRESS WSAEINPROGRESS

  376. +  #define DS_ETIMEDOUT   WSAETIMEDOUT

  377. +  #define DS_EWOULDBLOCK WSAEWOULDBLOCK

  378. +#endif

  379. +

  380. +#include "timeout_sem.h"

  381. +#ifdef __MINGW32__

  382. +  #undef DS_SEMAPHORE

  383. +#endif

  384. +

  385. +#ifdef DS_SEMAPHORE

  386. +#include 

  387. +#include 

  388. +#endif

  389. +

  390. +struct sem {

  391. +  int type;

  392. +  int initialized;

  393. +  int sockfd;

  394. +  int listenfd;

  395. +  void *id;

  396. +  char mutex_rx[1];

  397. +  char mutex_tx[1];

  398. +#ifdef DS_SEMAPHORE

  399. +  sem_t *sem_rd;

  400. +  sem_t *sem_wr;

  401. +#endif /*DS_SEMAPHORE*/

  402. +};

  403. +

  404. +#ifdef DS_SEMAPHORE

  405. +#ifdef __APPLE__

  406. +  static void ALRMhandler(int sig) {

  407. +  }

  408. +  static int sem_twait(sem_t *sem, int t) {

  409. +    int ret;

  410. +    alarm(t);

  411. +    ret = sem_wait(sem);

  412. +    printf("twait completen");

  413. +    return ret;

  414. +  }

  415. +  static void init_twait() {

  416. +    sigset_t none;

  417. +    struct sigaction sa;

  418. +    sigemptyset(&none;);

  419. +    sigprocmask(SIG_SETMASK, &none;, 0);

  420. +

  421. +    sa.sa_handler = ALRMhandler;

  422. +    sa.sa_flags = 0;

  423. +    sigemptyset(&sa.sa;_mask);

  424. +    sigaction(SIGALRM, &sa;, 0);

  425. +  }

  426. +#else

  427. +  static int sem_twait(sem_t *sem, int t) {

  428. +    struct timespec ts;

  429. +    clock_gettime(CLOCK_REALTIME, &ts;);

  430. +    ts.tv_sec += t;

  431. +    return(sem_timedwait(sem, &ts;));

  432. +  }

  433. +  static void init_twait() {}

  434. +#endif

  435. +#endif /*DS_SEMAPHORE */

  436. +

  437. +static int setblocking(int sock, int block)

  438. +{

  439. +       unsigned long opts;

  440. +#ifndef __MINGW32__

  441. +       opts = fcntl(sock,F_GETFL);

  442. +       if (opts < 0) {

  443. +               perror("fcntl(F_GETFL)");

  444. +               exit(EXIT_FAILURE);

  445. +       }

  446. +       opts = block ? (opts & ~O_NONBLOCK)

  447. +                     : (opts | O_NONBLOCK);

  448. +       if (fcntl(sock,F_SETFL,opts) < 0) {

  449. +               perror("fcntl(F_SETFL)");

  450. +               exit(EXIT_FAILURE);

  451. +       }

  452. +#else

  453. +       opts = !(block);

  454. +       if ( ioctlsocket( sock, FIONBIO, &opts; ) == SOCKET_ERROR )

  455. +       {

  456. +               perror("ioctlsocket");

  457. +               exit(EXIT_FAILURE);

  458. +       }

  459. +#endif

  460. +       return 0;

  461. +}

  462. +

  463. +static int timed_connect(int sockfd, const struct sockaddr *serv_addr,

  464. +                   socklen_t addrlen, int secs) {

  465. +  //Socket should already be non-blocking

  466. +  int res;

  467. +  fd_set myset;

  468. +  struct timeval tv;

  469. +  int valopt;

  470. +  socklen_t lon;

  471. +

  472. +  // Trying to connect with timeout

  473. +  res = connect(sockfd, serv_addr, addrlen);

  474. +  if (res < 0 ) {

  475. +     if (errno == DS_EINPROGRESS || errno == DS_EWOULDBLOCK || errno == 0) {

  476. +        fprintf(stderr, "EINPROGRESS in connect() - selectingn");

  477. +        do {

  478. +           tv.tv_sec = secs;

  479. +           tv.tv_usec = 0;

  480. +           FD_ZERO(&myset;);

  481. +           FD_SET(sockfd, &myset;);

  482. +           res = select(sockfd+1, NULL, &myset;, &myset;, &tv;);

  483. +           if (res < 0 && errno != EINTR) {

  484. +              fprintf(stderr, "Error connecting (select) %d - %sn", errno, strerror(errno));

  485. +              return -1;

  486. +           }

  487. +           else if (res > 0) {

  488. +              // Socket selected for write

  489. +              lon = sizeof(int);

  490. +              if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void*)(&valopt;), &lon;) < 0) {

  491. +                 fprintf(stderr, "Error in getsockopt() %d - %sn", errno, strerror(errno));

  492. +                 return -1;

  493. +              }

  494. +              // Check the value returned...

  495. +              if (valopt) {

  496. +                 fprintf(stderr, "Error in delayed connection() %d - %sn", valopt, strerror(valopt)

  497. +);

  498. +                 return -1;

  499. +              }

  500. +              break;

  501. +           }

  502. +           else {

  503. +              fprintf(stderr, "Timeout in select() - Cancelling!n");

  504. +              return -1;

  505. +           }

  506. +        } while (1);

  507. +     }

  508. +     else {

  509. +        fprintf(stderr, "Error connecting (connect) %d - %sn", errno, strerror(errno));

  510. +        return -1;

  511. +     }

  512. +  }

  513. +  // I hope that is all

  514. +  return 0;

  515. +}

  516. +static int timed_accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int secs) {

  517. +  //Socket should already be non-blocking

  518. +  int res;

  519. +  fd_set myset;

  520. +  struct timeval tv;

  521. +

  522. +  tv.tv_sec = secs;

  523. +  tv.tv_usec = 0;

  524. +  FD_ZERO(&myset;);

  525. +  FD_SET(sockfd, &myset;);

  526. +  res = select(sockfd+1, &myset;, NULL, NULL, &tv;);

  527. +  if (res < 0 && errno != EINTR) {

  528. +    fprintf(stderr, "Error accepting %d - %sn", errno, strerror(errno));

  529. +    return -1;

  530. +  }

  531. +  else if (res > 0) {

  532. +    // Socket selected for read

  533. +    return accept(sockfd, NULL, NULL);

  534. +  }

  535. +  errno = DS_ETIMEDOUT;

  536. +  return -1;

  537. +}

  538. +static int timed_recv(int sockfd, void *buf, size_t len, int flags, int secs) {

  539. +  //Socket should already be non-blocking

  540. +  int res;

  541. +  fd_set myset;

  542. +  struct timeval tv;

  543. +

  544. +  tv.tv_sec = secs;

  545. +  tv.tv_usec = 0;

  546. +  FD_ZERO(&myset;);

  547. +  FD_SET(sockfd, &myset;);

  548. +  res = select(sockfd+1, &myset;, NULL, NULL, &tv;);

  549. +  if (res < 0 && errno != EINTR) {

  550. +    fprintf(stderr, "Error accepting %d - %sn", errno, strerror(errno));

  551. +    return -1;

  552. +  }

  553. +  else if (res > 0) {

  554. +    // Socket selected for read

  555. +    return recv(sockfd, buf, len, flags);

  556. +  }

  557. +  errno = DS_ETIMEDOUT;

  558. +  return -1;

  559. +}

  560. +

  561. +static int timed_sockinit(int *port, int is_server)

  562. +{

  563. +    int sockfd;  // listen on sock_fd

  564. +    struct sockaddr_in my_addr;

  565. +    socklen_t peer_addr_size = sizeof(struct sockaddr_in);

  566. +    int yes=1;

  567. +

  568. +#ifdef __MINGW32__

  569. +    WSADATA wsaData;

  570. +    if(WSAStartup(MAKEWORD(2, 2), &wsaData;) !=0) {

  571. +      printf("WSAStartup failedn");

  572. +      exit(1);

  573. +    }

  574. +#endif

  575. +

  576. +    memset(&my;_addr, 0, sizeof(my_addr));

  577. +    my_addr.sin_family = AF_INET;

  578. +    my_addr.sin_addr.s_addr=INADDR_ANY;

  579. +    my_addr.sin_port = *port;

  580. +    if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) == -1) {

  581. +            perror("server: socket");

  582. +            exit(1);

  583. +    }

  584. +

  585. +    setblocking(sockfd, 0);

  586. +    if (is_server) {

  587. +      if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (const char *)&yes;,

  588. +              sizeof(int)) == -1) {

  589. +        perror("setsockopt");

  590. +        exit(1);

  591. +      }

  592. +

  593. +      if (bind(sockfd, (struct sockaddr *) &my;_addr,  sizeof(struct sockaddr_in)) == -1) {

  594. +              close(sockfd);

  595. +              perror("server: bind");

  596. +              exit(1);

  597. +      }

  598. +      if (listen(sockfd, 1) == -1) {

  599. +        perror("listen");

  600. +        exit(1);

  601. +      }

  602. +      if (getsockname(sockfd, (struct sockaddr *)&my;_addr, &peer;_addr_size) == -1) {

  603. +        perror("getsockname");

  604. +        exit(1);

  605. +      }

  606. +      if(my_addr.sin_port == 0) {

  607. +        printf("Failed to get portn");

  608. +        exit(1);

  609. +      }

  610. +      *port = my_addr.sin_port;

  611. +    } else {

  612. +      if (timed_connect(sockfd, (struct sockaddr *) &my;_addr,  sizeof(struct sockaddr_in), 10) == -1)

  613. +      {

  614. +        close(sockfd);

  615. +        perror("client: connect");

  616. +        exit(1);

  617. +      }

  618. +    }

  619. +

  620. +    return sockfd;

  621. +}

  622. +

  623. +int timed_semwait(void *_sem, int secs) {

  624. +  struct sem *sem = (struct sem *)_sem;

  625. +  int ok = -1;

  626. +  if(sem->type == DS_SOCKET) {

  627. +    if(! sem->initialized) {

  628. +      ok = timed_accept(sem->sockfd, NULL, NULL, secs);

  629. +      if(ok != -1) {

  630. +        sem->listenfd = sem->sockfd;

  631. +        sem->sockfd = ok;

  632. +        ok = 1;

  633. +        sem->initialized = 1;

  634. +      }

  635. +    } else {

  636. +      ok = (timed_recv(sem->sockfd, sem->mutex_rx, 1, 0, secs) == 1);

  637. +    }

  638. +  }

  639. +#ifdef DS_SEMAPHORE

  640. +  else if(sem->type == DS_SEMAPHORE) {

  641. +    ok = (sem_twait(sem->sem_rd, secs) == 0);

  642. +    if(! sem->initialized) {

  643. +      timed_semclean(sem);

  644. +      sem->initialized = 1;

  645. +    }

  646. +  }

  647. +#endif

  648. +  if(!ok && errno == DS_ETIMEDOUT) {

  649. +    ok = DS_TIMEOUT;

  650. +  }

  651. +  return ok;

  652. +}

  653. +

  654. +void timed_sempost(void *_sem) {

  655. +  struct sem *sem = (struct sem *)_sem;

  656. +  if(sem->type == DS_SOCKET) {

  657. +    send(sem->sockfd, sem->mutex_tx, 1, 0);

  658. +  }

  659. +#ifdef DS_SEMAPHORE

  660. +  else if(sem->type == DS_SEMAPHORE) {

  661. +    sem_post(sem->sem_wr);

  662. +  }

  663. +#endif

  664. +}

  665. +

  666. +void timed_semclean(void * _sem) {

  667. +#ifdef DS_SEMAPHORE

  668. +  struct sem *sem = (struct sem *) _sem;

  669. +  if(sem->type == DS_SEMAPHORE) {

  670. +    char sem1[80], sem2[80];

  671. +    snprintf(sem1, 80, "/dshow_sem1.%s", (char *)sem->id);

  672. +    snprintf(sem2, 80, "/dshow_sem2.%s", (char *)sem->id);

  673. +    sem_unlink(sem1);

  674. +    sem_unlink(sem2);

  675. +  }

  676. +#endif

  677. +}

  678. +

  679. +void *timed_seminit(unsigned int semtype, void *id, int is_host) {

  680. +  struct sem *sem;

  681. +  sem = (struct sem *)malloc(sizeof(struct sem));

  682. +  memset(sem, 0, sizeof(struct sem));

  683. +  sem->type = semtype;

  684. +  sem->id = id;

  685. +  sem->initialized = !(is_host);

  686. +  if(semtype == DS_SOCKET) {

  687. +    sem->listenfd = -1;

  688. +    sem->sockfd = timed_sockinit((int *)id, is_host);

  689. +    if(sem->sockfd == -1) {

  690. +      perror("sock_init");

  691. +      exit(1);

  692. +    }

  693. +  }

  694. +#ifdef DS_SEMAPHORE

  695. +  else if(semtype == DS_SEMAPHORE) {

  696. +    char semrd[80], semwr[80];

  697. +    init_twait();

  698. +    snprintf(semrd, 80, "/dshow_sem%d.%s", is_host ? 2 : 1, (char *)id);

  699. +    snprintf(semwr, 80, "/dshow_sem%d.%s", is_host ? 1 : 2, (char *)id);

  700. +    if(is_host) {

  701. +      sem->sem_rd = sem_open(semrd, O_CREAT, 0644, 0);

  702. +      sem->sem_wr = sem_open(semwr, O_CREAT, 0644, 0);

  703. +    } else {

  704. +      sem->sem_rd = sem_open(semrd, 0);

  705. +      sem->sem_wr = sem_open(semwr, 0);

  706. +      sem_unlink(semwr);

  707. +      sem_unlink(semrd);

  708. +    }

  709. +    if(sem->sem_rd == SEM_FAILED) {

  710. +      timed_semclean(sem);

  711. +      perror("sem_open(1)");

  712. +      exit(1);

  713. +    }

  714. +    if(sem->sem_wr == SEM_FAILED) {

  715. +      timed_semclean(sem);

  716. +      perror("sem_open(2)");

  717. +      exit(1);

  718. +    }

  719. +    //tell calling procedure that we are awake;

  720. +    if(! is_host) {

  721. +      sem_post(sem->sem_wr);

  722. +    }

  723. +  }

  724. +#endif /*DS_SEMAPHORE*/

  725. +  else {

  726. +    fprintf(stderr, "Unknown type specified: %dn", semtype);

  727. +    exit(1);

  728. +  }

  729. +  return sem;

  730. +}

  731. +

  732. +void timed_semdelete(void *_sem) {

  733. +  struct sem *sem = (struct sem *) _sem;

  734. +  if(sem->type == DS_SOCKET) {

  735. +    close(sem->sockfd);

  736. +    if(sem->listenfd != -1)

  737. +      close(sem->listenfd);

  738. +#ifdef DS_SEMAPHORE

  739. +  } else if(sem->type == DS_SEMAPHORE) {

  740. +    if(! sem->initialized)

  741. +      timed_semclean(sem);

  742. +    sem_close(sem->sem_wr);

  743. +    sem_close(sem->sem_rd);

  744. +#endif

  745. +  }

  746. +  free(sem);

  747. +}

  748. +

  749. Index: libmpcodecs/timeout_sem.h

  750. ===================================================================

  751. --- /dev/null   1970-01-01 00:00:00.000000000 +0000

  752. +++ libmpcodecs/timeout_sem.h   2010-03-12 07:48:02.000000000 -0800

  753. @@ -0,0 +1,10 @@

  754. +#define DS_SOCKET 0x01

  755. +#define DS_SEMAPHORE 0x02

  756. +

  757. +#define DS_TIMEOUT -1

  758. +

  759. +void *timed_seminit(unsigned int semtype, void *id, int is_host);

  760. +void timed_semclean(void *_sem);

  761. +void timed_sempost(void *_sem);

  762. +int timed_semwait(void *_sem, int secs);

  763. +void timed_semdelete(void *_sem);

主要是makefile的第二个trunk的改动。
其他的按照google project上的wiki安装就行了。但是，毕竟软件上的提升效果有限，小本子如果cpu实在太差，这种硬件上的短板还是无法依靠软件来解决。所以我的小本子还是放不了很大的视频文件。

本文 "linux coreavc" 由 K. Huang 首先发表于 xjpvictor's Blog 并以 CC BY-NC 4.0 许可证发布 © 2011
转载注明引用来源 https://blog.xjpvictor.info/2011/05/linux-coreavc/


推广：「 个人专属 VPN，独立 IP，无限流量，多机房切换，还可以屏蔽广告和恶意软件，每月最低仅 5 美元 」

打赏我

评论

你的邮箱地址不会被公开。必填项以 * 标出

无意义或不相关评论将被删除

允许使用以下html标签：<a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>

你可以上传文件，粘贴代码或长文至 Drop.it.r

本博客是言论不自由博客，评论只接受询问及赞同，不同观点请出门左转微博/发表于自己的博客。谢谢合作！

评论意味着你 同意 上传部分私人数据，包括邮箱和 IP, 这些数据不会被分享给第三方，不会用于商业用途或再推广用途。

更多相似文章

 

隐私设置 [关闭]


开博客就是为了装逼，装逼自然要支持 GDPR 隐私政策。请选择以下的隐私设置：