开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
decoder.c
资源名称：Visual C++视频音频开发实用工程案例精选.rar　[点击查看]
上传用户：tuheem
上传日期：2007-05-01
资源大小：21889k
文件大小：11k
源码类别：

多媒体编程

开发平台：

Visual C++

decoder.c：源码内容
  1. /*
  2.  * libmad - MPEG audio decoder library
  3.  */
  5. # ifdef HAVE_CONFIG_H
  6. #  include "config.h"
  7. # endif
  9. # include "global.h"
  11. # ifdef HAVE_SYS_TYPES_H
  12. #  include <sys/types.h>
  13. # endif
  15. # ifdef HAVE_SYS_WAIT_H
  16. #  include <sys/wait.h>
  17. # endif
  19. # ifdef HAVE_UNISTD_H
  20. #  include <unistd.h>
  21. # endif
  23. # ifdef HAVE_FCNTL_H
  24. #  include <fcntl.h>
  25. # endif
  27. # include <stdlib.h>
  29. # ifdef HAVE_ERRNO_H
  30. #  include <errno.h>
  31. # endif
  33. # include "stream.h"
  34. # include "frame.h"
  35. # include "synth.h"
  36. # include "decoder.h"
  38. void mad_decoder_init(struct mad_decoder *decoder, void *data,
  39.       enum mad_flow (*input_func)(void *,
  40.   struct mad_stream *),
  41.       enum mad_flow (*header_func)(void *,
  42.    struct mad_header const *),
  43.       enum mad_flow (*filter_func)(void *,
  44.    struct mad_stream const *,
  45.    struct mad_frame *),
  46.       enum mad_flow (*output_func)(void *,
  47.    struct mad_header const *,
  48.    struct mad_pcm *),
  49.       enum mad_flow (*error_func)(void *,
  50.   struct mad_stream *,
  51.   struct mad_frame *),
  52.       enum mad_flow (*message_func)(void *,
  53.     void *, unsigned int *))
  54. {
  55.   decoder->mode         = -1;
  57.   decoder->options      = 0;
  59.   decoder->async.pid    = 0;
  60.   decoder->async.in     = -1;
  61.   decoder->async.out    = -1;
  63.   decoder->sync         = 0;
  65.   decoder->cb_data      = data;
  67.   decoder->input_func   = input_func;
  68.   decoder->header_func  = header_func;
  69.   decoder->filter_func  = filter_func;
  70.   decoder->output_func  = output_func;
  71.   decoder->error_func   = error_func;
  72.   decoder->message_func = message_func;
  73. }
  75. int mad_decoder_finish(struct mad_decoder *decoder)
  76. {
  77. # if defined(USE_ASYNC)
  78.   if (decoder->mode == MAD_DECODER_MODE_ASYNC && decoder->async.pid) {
  79.     pid_t pid;
  80.     int status;
  82.     close(decoder->async.in);
  84.     do
  85.       pid = waitpid(decoder->async.pid, &status, 0);
  86.     while (pid == -1 && errno == EINTR);
  88.     decoder->mode = -1;
  90.     close(decoder->async.out);
  92.     decoder->async.pid = 0;
  93.     decoder->async.in  = -1;
  94.     decoder->async.out = -1;
  96.     if (pid == -1)
  97.       return -1;
  99.     return (!WIFEXITED(status) || WEXITSTATUS(status)) ? -1 : 0;
  100.   }
  101. # endif
  103.   return 0;
  104. }
  106. # if defined(USE_ASYNC)
  107. static
  108. enum mad_flow send_io(int fd, void const *data, size_t len)
  109. {
  110.   char const *ptr = data;
  111.   ssize_t count;
  113.   while (len) {
  114.     do
  115.       count = write(fd, ptr, len);
  116.     while (count == -1 && errno == EINTR);
  118.     if (count == -1)
  119.       return MAD_FLOW_BREAK;
  121.     len -= count;
  122.     ptr += count;
  123.   }
  125.   return MAD_FLOW_CONTINUE;
  126. }
  128. static
  129. enum mad_flow receive_io(int fd, void *buffer, size_t len)
  130. {
  131.   char *ptr = buffer;
  132.   ssize_t count;
  134.   while (len) {
  135.     do
  136.       count = read(fd, ptr, len);
  137.     while (count == -1 && errno == EINTR);
  139.     if (count == -1)
  140.       return (errno == EAGAIN) ? MAD_FLOW_IGNORE : MAD_FLOW_BREAK;
  141.     else if (count == 0)
  142.       return MAD_FLOW_STOP;
  144.     len -= count;
  145.     ptr += count;
  146.   }
  148.   return MAD_FLOW_CONTINUE;
  149. }
  151. static
  152. enum mad_flow receive_io_blocking(int fd, void *buffer, size_t len)
  153. {
  154.   int flags, blocking;
  155.   enum mad_flow result;
  157.   flags = fcntl(fd, F_GETFL);
  158.   if (flags == -1)
  159.     return MAD_FLOW_BREAK;
  161.   blocking = flags & ~O_NONBLOCK;
  163.   if (blocking != flags &&
  164.       fcntl(fd, F_SETFL, blocking) == -1)
  165.     return MAD_FLOW_BREAK;
  167.   result = receive_io(fd, buffer, len);
  169.   if (flags != blocking &&
  170.       fcntl(fd, F_SETFL, flags) == -1)
  171.     return MAD_FLOW_BREAK;
  173.   return result;
  174. }
  176. static
  177. enum mad_flow send(int fd, void const *message, unsigned int size)
  178. {
  179.   enum mad_flow result;
  181.   /* send size */
  183.   result = send_io(fd, &size, sizeof(size));
  185.   /* send message */
  187.   if (result == MAD_FLOW_CONTINUE)
  188.     result = send_io(fd, message, size);
  190.   return result;
  191. }
  193. static
  194. enum mad_flow receive(int fd, void **message, unsigned int *size)
  195. {
  196.   enum mad_flow result;
  197.   unsigned int actual;
  199.   if (*message == 0)
  200.     *size = 0;
  202.   /* receive size */
  204.   result = receive_io(fd, &actual, sizeof(actual));
  206.   /* receive message */
  208.   if (result == MAD_FLOW_CONTINUE) {
  209.     if (actual > *size)
  210.       actual -= *size;
  211.     else {
  212.       *size  = actual;
  213.       actual = 0;
  214.     }
  216.     if (*size > 0) {
  217.       if (*message == 0) {
  218. *message = malloc(*size);
  219. if (*message == 0)
  220.   return MAD_FLOW_BREAK;
  221.       }
  223.       result = receive_io_blocking(fd, *message, *size);
  224.     }
  226.     /* throw away remainder of message */
  228.     while (actual && result == MAD_FLOW_CONTINUE) {
  229.       char sink[256];
  230.       unsigned int len;
  232.       len = actual > sizeof(sink) ? sizeof(sink) : actual;
  234.       result = receive_io_blocking(fd, sink, len);
  236.       actual -= len;
  237.     }
  238.   }
  240.   return result;
  241. }
  243. static
  244. enum mad_flow check_message(struct mad_decoder *decoder)
  245. {
  246.   enum mad_flow result;
  247.   void *message = 0;
  248.   unsigned int size;
  250.   result = receive(decoder->async.in, &message, &size);
  252.   if (result == MAD_FLOW_CONTINUE) {
  253.     if (decoder->message_func == 0)
  254.       size = 0;
  255.     else {
  256.       result = decoder->message_func(decoder->cb_data, message, &size);
  258.       if (result == MAD_FLOW_IGNORE ||
  259.   result == MAD_FLOW_BREAK)
  260. size = 0;
  261.     }
  263.     if (send(decoder->async.out, message, size) != MAD_FLOW_CONTINUE)
  264.       result = MAD_FLOW_BREAK;
  265.   }
  267.   if (message)
  268.     free(message);
  270.   return result;
  271. }
  272. # endif
  274. static
  275. enum mad_flow error_default(void *data, struct mad_stream *stream,
  276.     struct mad_frame *frame)
  277. {
  278.   int *bad_last_frame = data;
  280.   switch (stream->error) {
  281.   case MAD_ERROR_BADCRC:
  282.     if (*bad_last_frame)
  283.       mad_frame_mute(frame);
  284.     else
  285.       *bad_last_frame = 1;
  287.     return MAD_FLOW_IGNORE;
  289.   default:
  290.     return MAD_FLOW_CONTINUE;
  291.   }
  292. }
  294. static
  295. int run_sync(struct mad_decoder *decoder)
  296. {
  297.   enum mad_flow (*error_func)(void *, struct mad_stream *, struct mad_frame *);
  298.   void *error_data;
  299.   int bad_last_frame = 0;
  300.   struct mad_stream *stream;
  301.   struct mad_frame *frame;
  302.   struct mad_synth *synth;
  303.   int result = 0;
  305.   if (decoder->input_func == 0)
  306.     return 0;
  308.   if (decoder->error_func) {
  309.     error_func = decoder->error_func;
  310.     error_data = decoder->cb_data;
  311.   }
  312.   else {
  313.     error_func = error_default;
  314.     error_data = &bad_last_frame;
  315.   }
  317.   stream = &decoder->sync->stream;
  318.   frame  = &decoder->sync->frame;
  319.   synth  = &decoder->sync->synth;
  321.   mad_stream_init(stream);
  322.   mad_frame_init(frame);
  323.   mad_synth_init(synth);
  325.   mad_stream_options(stream, decoder->options);
  327.   do {
  328.     switch (decoder->input_func(decoder->cb_data, stream)) {
  329.     case MAD_FLOW_STOP:
  330.       goto done;
  331.     case MAD_FLOW_BREAK:
  332.       goto fail;
  333.     case MAD_FLOW_IGNORE:
  334.       continue;
  335.     case MAD_FLOW_CONTINUE:
  336.       break;
  337.     }
  339.     while (1) {
  340. # if defined(USE_ASYNC)
  341.       if (decoder->mode == MAD_DECODER_MODE_ASYNC) {
  342. switch (check_message(decoder)) {
  343. case MAD_FLOW_IGNORE:
  344. case MAD_FLOW_CONTINUE:
  345.   break;
  346. case MAD_FLOW_BREAK:
  347.   goto fail;
  348. case MAD_FLOW_STOP:
  349.   goto done;
  350. }
  351.       }
  352. # endif
  354.       if (decoder->header_func) {
  355. if (mad_header_decode(&frame->header, stream) == -1) {
  356.   if (!MAD_RECOVERABLE(stream->error))
  357.     break;
  359.   switch (error_func(error_data, stream, frame)) {
  360.   case MAD_FLOW_STOP:
  361.     goto done;
  362.   case MAD_FLOW_BREAK:
  363.     goto fail;
  364.   case MAD_FLOW_IGNORE:
  365.   case MAD_FLOW_CONTINUE:
  366.   default:
  367.     continue;
  368.   }
  369. }
  371. switch (decoder->header_func(decoder->cb_data, &frame->header)) {
  372. case MAD_FLOW_STOP:
  373.   goto done;
  374. case MAD_FLOW_BREAK:
  375.   goto fail;
  376. case MAD_FLOW_IGNORE:
  377.   continue;
  378. case MAD_FLOW_CONTINUE:
  379.   break;
  380. }
  381.       }
  383.       if (mad_frame_decode(frame, stream) == -1) {
  384. if (!MAD_RECOVERABLE(stream->error))
  385.   break;
  387. switch (error_func(error_data, stream, frame)) {
  388. case MAD_FLOW_STOP:
  389.   goto done;
  390. case MAD_FLOW_BREAK:
  391.   goto fail;
  392. case MAD_FLOW_IGNORE:
  393.   break;
  394. case MAD_FLOW_CONTINUE:
  395. default:
  396.   continue;
  397. }
  398.       }
  399.       else
  400. bad_last_frame = 0;
  402.       if (decoder->filter_func) {
  403. switch (decoder->filter_func(decoder->cb_data, stream, frame)) {
  404. case MAD_FLOW_STOP:
  405.   goto done;
  406. case MAD_FLOW_BREAK:
  407.   goto fail;
  408. case MAD_FLOW_IGNORE:
  409.   continue;
  410. case MAD_FLOW_CONTINUE:
  411.   break;
  412. }
  413.       }
  415.       mad_synth_frame(synth, frame);
  417.       if (decoder->output_func) {
  418. switch (decoder->output_func(decoder->cb_data,
  419.      &frame->header, &synth->pcm)) {
  420. case MAD_FLOW_STOP:
  421.   goto done;
  422. case MAD_FLOW_BREAK:
  423.   goto fail;
  424. case MAD_FLOW_IGNORE:
  425. case MAD_FLOW_CONTINUE:
  426.   break;
  427. }
  428.       }
  429.     }
  430.   }
  431.   while (stream->error == MAD_ERROR_BUFLEN);
  433.  fail:
  434.   result = -1;
  436.  done:
  437.   mad_synth_finish(synth);
  438.   mad_frame_finish(frame);
  439.   mad_stream_finish(stream);
  441.   return result;
  442. }
  444. # if defined(USE_ASYNC)
  445. static
  446. int run_async(struct mad_decoder *decoder)
  447. {
  448.   pid_t pid;
  449.   int ptoc[2], ctop[2], flags;
  451.   if (pipe(ptoc) == -1)
  452.     return -1;
  454.   if (pipe(ctop) == -1) {
  455.     close(ptoc[0]);
  456.     close(ptoc[1]);
  457.     return -1;
  458.   }
  460.   flags = fcntl(ptoc[0], F_GETFL);
  461.   if (flags == -1 ||
  462.       fcntl(ptoc[0], F_SETFL, flags | O_NONBLOCK) == -1) {
  463.     close(ctop[0]);
  464.     close(ctop[1]);
  465.     close(ptoc[0]);
  466.     close(ptoc[1]);
  467.     return -1;
  468.   }
  470.   pid = fork();
  471.   if (pid == -1) {
  472.     close(ctop[0]);
  473.     close(ctop[1]);
  474.     close(ptoc[0]);
  475.     close(ptoc[1]);
  476.     return -1;
  477.   }
  479.   decoder->async.pid = pid;
  481.   if (pid) {
  482.     /* parent */
  484.     close(ptoc[0]);
  485.     close(ctop[1]);
  487.     decoder->async.in  = ctop[0];
  488.     decoder->async.out = ptoc[1];
  490.     return 0;
  491.   }
  493.   /* child */
  495.   close(ptoc[1]);
  496.   close(ctop[0]);
  498.   decoder->async.in  = ptoc[0];
  499.   decoder->async.out = ctop[1];
  501.   _exit(run_sync(decoder));
  503.   /* not reached */
  504.   return -1;
  505. }
  506. # endif
  508. int mad_decoder_run(struct mad_decoder *decoder, enum mad_decoder_mode mode)
  509. {
  510.   int result;
  511.   int (*run)(struct mad_decoder *) = 0;
  513.   switch (decoder->mode = mode) {
  514.   case MAD_DECODER_MODE_SYNC:
  515.     run = run_sync;
  516.     break;
  518.   case MAD_DECODER_MODE_ASYNC:
  519. # if defined(USE_ASYNC)
  520.     run = run_async;
  521. # endif
  522.     break;
  523.   }
  525.   if (run == 0)
  526.     return -1;
  528.   decoder->sync = malloc(sizeof(*decoder->sync));
  529.   if (decoder->sync == 0)
  530.     return -1;
  532.   result = run(decoder);
  534.   free(decoder->sync);
  535.   decoder->sync = 0;
  537.   return result;
  538. }
  540. int mad_decoder_message(struct mad_decoder *decoder,
  541. void *message, unsigned int *len)
  542. {
  543. # if defined(USE_ASYNC)
  544.   if (decoder->mode != MAD_DECODER_MODE_ASYNC ||
  545.       send(decoder->async.out, message, *len) != MAD_FLOW_CONTINUE ||
  546.       receive(decoder->async.in, &message, len) != MAD_FLOW_CONTINUE)
  547.     return -1;
  549.   return 0;
  550. # else
  551.   return -1;
  552. # endif
  553. }