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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
mpeg2_transport.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：17k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

mpeg2_transport.c：源码内容
  2. #include "mpeg4ip.h"
  3. #include "mpeg2_transport.h"
  4. #include <assert.h>
  5. #include "mpeg2t_private.h"
  6. #define DEBUG 1
  7. #ifdef DEBUG
  8. #define CHECK_MP2T_HEADER assert(*pHdr == MPEG2T_SYNC_BYTE)
  9. #else
  10. #define CHECK_MP2T_HEADER 
  11. #endif
  13. uint32_t mpeg2t_find_sync_byte (const uint8_t *buffer, uint32_t buflen)
  14. {
  15.   uint32_t offset;
  17.   offset = 0;
  19.   while (offset < buflen) {
  20.     if (buffer[offset] == MPEG2T_SYNC_BYTE) {
  21.       return (offset);
  22.     }
  23.     offset++;
  24.   }
  25.   return (offset);
  26. }
  28. uint32_t mpeg2t_transport_error_indicator (const uint8_t *pHdr)
  29. {
  31.   CHECK_MP2T_HEADER;
  33.   return ((pHdr[1] >> 7) & 0x1);
  34. }
  36. uint32_t mpeg2t_payload_unit_start_indicator (const uint8_t *pHdr)
  37. {
  38.   CHECK_MP2T_HEADER;
  40.   return ((pHdr[1] >> 6) & 0x1);
  41. }
  43. uint16_t mpeg2t_pid (const uint8_t *pHdr)
  44. {
  45.   int pid;
  46.   CHECK_MP2T_HEADER;
  48.   pid = (pHdr[1] & 0x1f) << 8;
  49.   pid |= pHdr[2];
  51.   return (pid);
  52. }
  54. uint32_t mpeg2t_adaptation_control (const uint8_t *pHdr)
  55. {
  56.   CHECK_MP2T_HEADER;
  58.   return ((pHdr[3] >> 4) & 0x3);
  59. }
  61. uint32_t mpeg2t_continuity_counter (const uint8_t *pHdr)
  62. {
  63.   CHECK_MP2T_HEADER;
  65.   return (pHdr[3] & 0xf);
  66. }
  68. const uint8_t *mpeg2t_transport_payload_start (const uint8_t *pHdr,
  69.      uint32_t *payload_len)
  70. {
  71.   uint32_t adaption_control;
  72.   CHECK_MP2T_HEADER;
  74.   if (mpeg2t_transport_error_indicator(pHdr) != 0) {
  75.     *payload_len = 0;
  76.     return NULL;
  77.   }
  79.   adaption_control = mpeg2t_adaptation_control(pHdr);
  81.   if (adaption_control == 1) {
  82.     *payload_len = 184;
  83.     return pHdr + 4;
  84.   }
  85.   if (adaption_control == 3) {
  86.     if (pHdr[4] > 183) {
  87.       *payload_len = 0;
  88.       return NULL;
  89.     }
  90.     *payload_len = 183 - pHdr[4];
  91.     return pHdr + 5 + pHdr[4];
  92.   }
  94.   *payload_len = 0;
  95.   return NULL;
  96. }
  98. static void mpeg2t_start_join_pak (mpeg2t_pid_t *pidptr,
  99.    const uint8_t *bufstart,
  100.    uint32_t buflen,
  101.    uint32_t seqlen, 
  102.    uint32_t cc)
  103. {
  104.   if (seqlen == 0) {
  105.     if (pidptr->data_len_max < buflen) {
  106.       pidptr->data = (uint8_t *)realloc(pidptr->data, buflen + 4096);
  107.       if (pidptr->data == NULL) {
  108. pidptr->data_len_max = 0;
  109. return;
  110.       }
  111.       pidptr->data_len_max = buflen + 4096;
  112.     }
  113.   } else if (seqlen > pidptr->data_len_max) {
  114.     pidptr->data = (uint8_t *)realloc(pidptr->data, seqlen);
  115.     if (pidptr->data == NULL) {
  116.       pidptr->data_len_max = 0;
  117.       return;
  118.     }
  119.     pidptr->data_len_max = seqlen;
  120.   }
  121.   pidptr->data_len = seqlen;
  122.   pidptr->data_len_loaded = buflen;
  123.   memcpy(pidptr->data, bufstart, buflen);
  124.   pidptr->lastcc = cc;
  125. }
  127. static int mpeg2t_join_pak (mpeg2t_pid_t *pidptr,
  128.     const uint8_t *bufstart,
  129.     uint32_t buflen,
  130.     uint32_t cc)
  131. {
  132.   uint32_t nextcc;
  133.   uint32_t remaining;
  134.   if (pidptr->data_len_loaded == 0) {
  135.     mpeg2t_message(LOG_WARNING, 
  136.    "Trying to add to unstarted packet - PID %x", 
  137.    pidptr->pid);
  138.     return -1;
  139.   }
  140.   nextcc = (pidptr->lastcc + 1) & 0xf;
  141.   if (nextcc != cc) {
  142.     mpeg2t_message(LOG_ERR, "Illegal cc value %d - should be %d - PID %x", 
  143.    cc, nextcc, pidptr->pid);
  144.     pidptr->data_len_loaded = 0;
  145.     return -1;
  146.   }
  147.   pidptr->lastcc = cc;
  148.   if (pidptr->data_len == 0) {
  149.     remaining = pidptr->data_len_max - pidptr->data_len_loaded;
  150.     if (remaining < buflen) {
  151.       pidptr->data = (uint8_t *)realloc(pidptr->data, 
  152. pidptr->data_len_max + 4096);
  153.       if (pidptr->data == NULL) {
  154. pidptr->data_len_max = 0;
  155. return -1;
  156.       }
  157.       pidptr->data_len_max = pidptr->data_len_max + 4096;
  158.     }
  159.   } else {
  160.     remaining = pidptr->data_len - pidptr->data_len_loaded;
  162.     buflen = buflen > remaining ? remaining : buflen;
  163.   }
  164.   memcpy(pidptr->data + pidptr->data_len_loaded,
  165.  bufstart, 
  166.  buflen);
  167.   pidptr->data_len_loaded += buflen;
  168.   if (pidptr->data_len == 0 || pidptr->data_len_loaded < pidptr->data_len) 
  169.     return 0;
  170.   // Indicate that next one starts from beginning
  171.   pidptr->data_len_loaded = 0;
  172.   return 1;
  173. }
  175. static mpeg2t_pid_t *mpeg2t_lookup_pid (mpeg2t_t *ptr,
  176. uint16_t pid)
  177. {
  178.   mpeg2t_pid_t *pidptr = &ptr->pas.pid;
  180.   while (pidptr != NULL && pidptr->pid != pid) {
  181.     pidptr = pidptr->next_pid;
  182.   }
  183.   return pidptr;
  184. }
  186. static void add_to_pidQ (mpeg2t_t *ptr, mpeg2t_pid_t *pidptr)
  187. {
  188.   mpeg2t_pid_t *p = &ptr->pas.pid;
  190.   while (p->next_pid != NULL) {
  191.     p = p->next_pid;
  192.   }
  193.   p->next_pid = pidptr;
  194. }
  196. static void create_pmap (mpeg2t_t *ptr, uint16_t prog_num, uint16_t pid)
  197. {
  198.   mpeg2t_pmap_t *pmap;
  200.   mpeg2t_message(LOG_INFO, "Adding pmap prog_num %x pid %x", prog_num, pid);
  201.   pmap = MALLOC_STRUCTURE(mpeg2t_pmap_t);
  202.   if (pmap == NULL) return;
  203.   memset(pmap, 0, sizeof(*pmap));
  204.   pmap->pid.pak_type = MPEG2T_PROG_MAP_PAK;
  205.   pmap->pid.pid = pid;
  206.   pmap->program_number = prog_num;
  207.   add_to_pidQ(ptr, &pmap->pid);
  208. }
  210. static void create_es (mpeg2t_t *ptr, 
  211.        uint16_t pid, 
  212.        uint8_t stream_type,
  213.        const uint8_t *es_data,
  214.        uint32_t es_info_len)
  215. {
  216.   mpeg2t_es_t *es;
  218.   mpeg2t_message(LOG_INFO, 
  219.  "Adding ES PID %x stream type %d", pid, stream_type);
  220.   es = MALLOC_STRUCTURE(mpeg2t_es_t);
  221.   if (es == NULL) return;
  222.   memset(es, 0, sizeof(*es));
  223.   es->pid.pak_type = MPEG2T_ES_PAK;
  224.   es->pid.pid = pid;
  225.   es->stream_type = stream_type;
  226.   if (es_info_len != 0) {
  227.     es->es_data = (uint8_t *)malloc(es_info_len);
  228.     if (es->es_data != NULL) {
  229.       memcpy(es->es_data, es_data, es_info_len);
  230.       es->es_info_len = es_info_len;
  231.     }
  232.   }
  233.   es->work_max_size = 4096;
  234.   add_to_pidQ(ptr, &es->pid);
  235. }
  236.   
  237. static int mpeg2t_process_pas (mpeg2t_t *ptr, const uint8_t *buffer)
  238. {
  239.   uint32_t buflen;
  240.   uint32_t section_len;
  241.   uint32_t len;
  242.   const uint8_t *mapptr;
  243.   uint16_t prog_num, pid;
  244.   const uint8_t *pasptr;
  245.   int ret;
  247.   buflen = 188;
  248.   // process pas pointer
  249.   pasptr = mpeg2t_transport_payload_start(buffer, &buflen);
  251.   if (pasptr == NULL) return 0;
  253.   if (mpeg2t_payload_unit_start_indicator(buffer) == 0) {
  254.     ret = mpeg2t_join_pak(&ptr->pas.pid, 
  255.   pasptr,
  256.   buflen,
  257.   mpeg2t_continuity_counter(buffer));
  258.     if (ret <= 0) return 0; // not done, or bad
  259.     pasptr = ptr->pas.pid.data;
  260.     section_len = ptr->pas.pid.data_len;
  261.   } else {
  262.     if (*pasptr + 1 > buflen) 
  263.       return 0;
  264.     buflen -= *pasptr + 1;
  265.     pasptr += *pasptr + 1; // go through the pointer field
  266.     
  267.     if (*pasptr != 0 || (pasptr[1] & 0xc0) != 0x80) {
  268.       mpeg2t_message(LOG_ERR, "PAS field not 0");
  269.       return 0;
  270.     }
  271.     section_len = ((pasptr[1] << 8) | pasptr[2]) & 0x3ff; 
  272.     // remove table_id, section length fields
  273.     pasptr += 3;
  274.     buflen -= 3;
  275.     if (buflen < section_len) {
  276.       mpeg2t_start_join_pak(&ptr->pas.pid,
  277.     pasptr, // start after section len
  278.     buflen,
  279.     section_len,
  280.     mpeg2t_continuity_counter(buffer));
  281.       return 0;
  282.     }
  283.     // At this point, pasptr points to transport_stream_id
  284.   }
  285.   
  286.   ptr->pas.transport_stream_id = ((pasptr[0] << 8 | pasptr[1]));
  287.   ptr->pas.version_number = (pasptr[2] >> 1) & 0x1f;
  288.   mapptr = &pasptr[5];
  289.   section_len -= 5 + 4; // remove CRC and stuff before map list
  290.   for (len = 0; len < section_len; len += 4, mapptr += 4) {
  291.     prog_num = (mapptr[0] << 8) | mapptr[1];
  292.     if (prog_num != 0) {
  293.       pid = ((mapptr[2] << 8) | mapptr[3]) & 0x1fff;
  294.       if (mpeg2t_lookup_pid(ptr, pid) == NULL) {
  295. create_pmap(ptr, prog_num, pid);
  296.       }
  297.     }
  298.   }
  299.   return 1;
  300. }
  302. static int mpeg2t_process_pmap (mpeg2t_t *ptr, 
  303. mpeg2t_pid_t *ifptr,
  304. const uint8_t *buffer)
  305. {
  306.   uint32_t buflen;
  307.   uint32_t section_len;
  308.   uint32_t len, es_len;
  309.   uint16_t prog_num, pcr_pid;
  310.   const uint8_t *pmapptr;
  311.   mpeg2t_pmap_t *pmap_pid = (mpeg2t_pmap_t *)ifptr;
  312.   int ret;
  313.   uint8_t stream_type;
  314.   uint16_t e_pid;
  316.   buflen = 188;
  317.   // process pas pointer
  318.   pmapptr = mpeg2t_transport_payload_start(buffer, &buflen);
  319.   if (pmapptr == NULL) return 0;
  321.   if (mpeg2t_payload_unit_start_indicator(buffer) == 0) {
  322.     ret = mpeg2t_join_pak(ifptr, 
  323.   pmapptr,
  324.   buflen,
  325.   mpeg2t_continuity_counter(buffer));
  326.     if (ret <= 0) return 0;
  327.     pmapptr = ifptr->data;
  328.     section_len = ifptr->data_len;
  329.   } else {
  330.     if (*pmapptr + 1 > buflen) 
  331.       return 0;
  332.     buflen -= *pmapptr + 1;
  333.     pmapptr += *pmapptr + 1; // go through the pointer field
  334.     if (*pmapptr != 2 || (pmapptr[1] & 0xc0) != 0x80) {
  335.       mpeg2t_message(LOG_ERR, "PMAP start field not 2");
  336.       return 0;
  337.     }
  338.     section_len = ((pmapptr[1] << 8) | pmapptr[2]) & 0x3ff; 
  339.     pmapptr += 3;
  340.     buflen -= 3;
  342.     if (buflen < section_len) {
  343.       mpeg2t_start_join_pak(ifptr,
  344.     pmapptr,
  345.     buflen,
  346.     section_len,
  347.     mpeg2t_continuity_counter(buffer));
  348.       return 0;
  349.     }
  350.     // pmapptr points to program number
  351.   }
  353.     
  354.   prog_num = ((pmapptr[0] << 8) | pmapptr[1]);
  355.   if (prog_num != pmap_pid->program_number) {
  356.     mpeg2t_message(LOG_ERR, 
  357.    "Prog Map error - program number doesn't match - pid %x orig %x from pak %x", 
  358.    pmap_pid->pid.pid, pmap_pid->program_number, prog_num);
  359.     return 0;
  360.   }
  361.   pmap_pid->version_number = (pmapptr[2] >> 1) & 0x1f;
  363.   pcr_pid = ((pmapptr[5] << 8) | pmapptr[6]) & 0x1fff;
  364.   if (pcr_pid != 0x1fff) {
  365.     mpeg2t_message(LOG_DEBUG, "Have PCR pid of %x", pcr_pid);
  366.   }
  367.   pmapptr += 7;
  368.   section_len -= 7; // remove all the fixed fields to get the prog info len
  369.   len = ((pmapptr[0] << 8) | pmapptr[1]) & 0xfff;
  370.   pmapptr += 2;
  371.   section_len -= 2;
  372.   if (len != 0) {
  373.     if (len > section_len) return 0;
  375.     if (len == pmap_pid->prog_info_len) {
  376.       // same length - do a compare
  377.     } else {
  378.     }
  379.     pmapptr += len;
  380.     section_len -= len;
  381.   }
  382.   section_len -= 4; // remove CRC
  383.   len = 0;
  384.   while (len < section_len) {
  385.     stream_type = pmapptr[0];
  386.     e_pid = ((pmapptr[1] << 8) | pmapptr[2]) & 0x1fff;
  387.     es_len = ((pmapptr[3] << 8) | pmapptr[4]) & 0xfff;
  388.     if (es_len + len > section_len) return 0;
  389.     if (mpeg2t_lookup_pid(ptr, e_pid) == NULL) {
  390.       mpeg2t_message(LOG_INFO, "Creating es pid %x", e_pid);
  391.       create_es(ptr, e_pid, stream_type, &pmapptr[5], es_len);
  392.     }
  393.     // create_es
  394.     len += 5 + es_len;
  395.     pmapptr += 5 + es_len;
  396.   }
  397.   return 1;
  398. }
  400. static void clean_es_data (mpeg2t_es_t *es_pid) 
  401. {
  402.   switch (es_pid->stream_type) {
  403.   case 1:
  404.   case 2:
  405.     // mpeg1 or mpeg2 video
  406.     es_pid->work_state = 0;
  407.     es_pid->header = 0;
  408.     es_pid->work_loaded = 0;
  409.     es_pid->have_seq_header = 0;
  410.     break;
  411.   case 3:
  412.   case 4:
  413.     // mpeg1/mpeg2 audio (mp3 codec
  414.     if (es_pid->work != NULL ) {
  415.       free(es_pid->work);
  416.       es_pid->work = NULL;
  417.     }
  418.     es_pid->work_loaded = 0;
  419.     es_pid->left = 0;
  420.     break;
  421.   case 0xf:
  422.     // aac
  423.     break;
  424.   }
  425. }  
  427. void mpeg2t_malloc_es_work (mpeg2t_es_t *es_pid, uint32_t frame_len)
  428. {
  429.   uint8_t *frameptr;
  431.   if (es_pid->work == NULL || es_pid->work->frame_len < frame_len) {
  432.     if (es_pid->work != NULL) {
  433.       free(es_pid->work);
  434.       es_pid->work = NULL;
  435.     }
  436.     frameptr = (uint8_t *)malloc(sizeof(mpeg2t_frame_t) + frame_len);
  437.     if (frameptr == NULL) return;
  438.     es_pid->work = (mpeg2t_frame_t *)frameptr;
  439.     es_pid->work->frame = frameptr + sizeof(mpeg2t_frame_t);
  440.     es_pid->work->frame_len = frame_len;
  441.   }
  442.   es_pid->work->next_frame = NULL;
  443.   es_pid->work->have_ps_ts = es_pid->have_ps_ts;
  444.   es_pid->work->ps_ts = es_pid->ps_ts;
  445.   es_pid->have_ps_ts = 0;
  446.   es_pid->work_loaded = 0;
  447. }
  449. void mpeg2t_finished_es_work (mpeg2t_es_t *es_pid,
  450.       uint32_t frame_len)
  451. {
  452.   mpeg2t_frame_t *p;
  453.   es_pid->work->frame_len = frame_len;
  454.   if (es_pid->list == NULL) {
  455.     es_pid->list = es_pid->work;
  456.   } else {
  457.     p = es_pid->list;
  458.     while (p->next_frame != NULL) p = p->next_frame;
  459.     p->next_frame = es_pid->work;
  460.   }
  461.   es_pid->work = NULL;
  462.   es_pid->work_loaded = 0;
  463. }
  465.   
  466. static int mpeg2t_process_es (mpeg2t_t *ptr, 
  467.       mpeg2t_pid_t *ifptr,
  468.       const uint8_t *buffer)
  469. {
  470.   uint32_t buflen;
  471.   uint32_t pes_len;
  472.   const uint8_t *esptr;
  473.   mpeg2t_es_t *es_pid = (mpeg2t_es_t *)ifptr;
  474.   int read_pes_options;
  475.   uint8_t stream_id;
  476.   uint32_t nextcc, pakcc;
  477.   int ret;
  479.   nextcc = ifptr->lastcc;
  480.   nextcc = (nextcc + 1) & 0xf;
  481.   pakcc = mpeg2t_continuity_counter(buffer);
  482.   if (nextcc != pakcc) {
  483.     mpeg2t_message(LOG_ERR, "cc error in PES %x should be %d is %d", 
  484.    ifptr->pid, nextcc, pakcc);
  485.     clean_es_data(es_pid);
  486.   }
  487.   ifptr->lastcc = pakcc;
  489.   buflen = 188;
  490.   // process pas pointer
  491.   esptr = mpeg2t_transport_payload_start(buffer, &buflen);
  492.   if (esptr == NULL) return -1;
  494.   
  495.   if (mpeg2t_payload_unit_start_indicator(buffer) != 0) {
  496.     // start of PES packet
  497.     if ((esptr[0] != 0) ||
  498. (esptr[1] != 0) ||
  499. (esptr[2] != 1)) {
  500.       mpeg2t_message(LOG_ERR, 
  501.      "Illegal start to PES packet - pid %x - %02x %02x %02x",
  502.      ifptr->pid, esptr[0], esptr[1], esptr[2]);
  503.       return -1;
  504.     }
  505.     stream_id = es_pid->stream_id = esptr[3];
  506.     pes_len = (esptr[4] << 8) | esptr[5];
  507.     esptr += 6;
  508.     buflen -= 6;
  509.     
  510.     read_pes_options = 0;
  511.     // do we have header extensions
  512.     switch ((stream_id & 0x70) >> 4) {
  513.     default:
  514.       if ((stream_id == 0xbd) ||
  515.     (stream_id >= 0xf3 && stream_id <= 0xf7) ||
  516.     (stream_id >= 0xf9 && stream_id <= 0xff)) {
  517. read_pes_options = 1;
  518. break;
  519.       }
  520.       // fall through
  521.     case 4:
  522.     case 5:
  523.     case 6:
  524.       if (esptr[2] <= buflen - 3) {
  525. // multiple PES for header
  526. read_pes_options = 1;
  527.       } else {
  528. // don't have enough to read the header
  529.       }
  530.       break;
  531.     }
  532.       
  533.     if (read_pes_options) {
  534.       if (esptr[2] + 3 > buflen) {
  535. return 0;
  536.       }
  537.       //mpeg2t_read_pes_options(es_pid, esptr);
  538.       if (((esptr[1] & 0xc0) == 0x80) ||
  539.   ((esptr[1] & 0xc0) == 0xc0)) {
  540. // read presentation timestamp
  541. uint64_t pts;
  542. #if 1
  543. mpeg2t_message(LOG_DEBUG, "Stream %x %02x %02x %02x", 
  544.        stream_id, esptr[0], esptr[1], esptr[2]);
  545. mpeg2t_message(LOG_DEBUG, "PTS %02x %02x %02x %02x %02x", 
  546.        esptr[3], esptr[4], esptr[5], esptr[6], esptr[7]);
  547. #endif
  548. if (((esptr[1] >> 6) & 0x3) !=
  549.     ((esptr[3] >> 4) & 0xf)) {
  550.   mpeg2t_message(LOG_ERR, "PID %x Timestamp flag value not same %x %x",
  551.  es_pid->pid.pid, esptr[1], esptr[2]);
  552.   return -1;
  553. }
  554. pts = ((esptr[3] >> 1) & 0x7);
  555. pts <<= 8;
  556. pts |= esptr[4];
  557. pts <<= 7;
  558. pts |= ((esptr[5] >> 1) & 0x7f);
  559. pts <<= 8;
  560. pts |= esptr[6];
  561. pts <<= 7;
  562. pts |= ((esptr[7] >> 1) & 0x7f);
  563. es_pid->have_ps_ts = 1;
  564. es_pid->ps_ts = pts;
  565.       }
  566.       buflen -= esptr[2] + 3;
  567.       esptr += esptr[2] + 3;
  568.     }
  569.   // process esptr, buflen
  570.     if (buflen == 0) {
  571.       es_pid->have_ps_ts = 0;
  572.       return 0;
  573.     }
  574.   } else {
  575.     // 0 in Payload start - process frame at start
  576.     read_pes_options = 0;
  577.   }
  578.   // have start of data is at esptr, buflen data
  579.   ret = 0;
  580.   switch (es_pid->stream_type) {
  581.   case 1:
  582.   case 2:
  583.     // mpeg1 or mpeg2 video
  584.     ret = process_mpeg2t_mpeg_video(es_pid, esptr, buflen);
  585.     break;
  586.   case 3:
  587.   case 4:
  588.     // mpeg1/mpeg2 audio (mp3 codec
  589.     ret = process_mpeg2t_mpeg_audio(es_pid, esptr, buflen);
  590.   break;
  591.   case 0xf:
  592.     // aac
  593.     break;
  594.   }
  595.   es_pid->have_ps_ts = 0;
  596.   return ret;
  597. }
  598.     
  599.       
  600. mpeg2t_pid_t *mpeg2t_process_buffer (mpeg2t_t *ptr, 
  601.      const uint8_t *buffer, 
  602.      uint32_t buflen,
  603.      uint32_t *buflen_used)
  604. {
  605.   uint32_t offset;
  606.   uint32_t remaining;
  607.   uint32_t used;
  608.   uint16_t rpid;
  609.   mpeg2t_pid_t *pidptr;
  610.   int ret;
  612.   used = 0;
  613.   remaining = buflen;
  614.   while (used < buflen) {
  615.     offset = mpeg2t_find_sync_byte(buffer, remaining);
  616.     if (offset >= remaining) {
  617.       *buflen_used = buflen;
  618.       return NULL;
  619.     }
  620.     remaining -= offset;
  621.     buffer += offset;
  622.     used += offset;
  624.     if (remaining < 188) {
  625.       *buflen_used = used;
  626.       return NULL;
  627.     }
  629.     // we have a complete buffer
  630.     rpid = mpeg2t_pid(buffer);
  631. #if 1
  632.     mpeg2t_message(LOG_DEBUG, "Buffer- PID %x start %d cc %d",
  633.    rpid, mpeg2t_payload_unit_start_indicator(buffer),
  634.    mpeg2t_continuity_counter(buffer));
  635. #endif
  636.     if (rpid == 0x1fff) {
  637.       // just skip
  638.     } else {
  639.       // look up pid in table
  640.       pidptr = mpeg2t_lookup_pid(ptr, rpid);
  641.       if (pidptr != NULL) {
  642. // okay - we've got a valid pid ptr
  643. switch (pidptr->pak_type) {
  644. case MPEG2T_PAS_PAK:
  645.   ret = mpeg2t_process_pas(ptr, buffer);
  646.   if (ret > 0) {
  647.     *buflen_used = used + 188;
  648.     return pidptr;
  649.   }
  650.   break;
  651. case MPEG2T_PROG_MAP_PAK:
  652.   ret = mpeg2t_process_pmap(ptr, pidptr, buffer);
  653.   if (ret > 0) {
  654.     *buflen_used = used + 188;
  655.     return pidptr;
  656.   }
  657.   break;
  658. case MPEG2T_ES_PAK:
  659.   if (mpeg2t_process_es(ptr, pidptr, buffer) > 0) {
  660.     *buflen_used = used + 188;
  661.     return pidptr;
  662.   }
  663.   break;
  664. }
  665.       }
  666.     }
  668.     used += 188;
  669.     buffer += 188;
  670.     remaining -= 188;
  671.   }
  672.   *buflen_used = buflen;
  673.   return NULL;
  674. }
  675.   
  676. mpeg2t_t *create_mpeg2_transport (void)
  677. {
  678.   mpeg2t_t *ptr;
  680.   ptr = MALLOC_STRUCTURE(mpeg2t_t);
  681.   memset(ptr, 0, sizeof(ptr));
  682.   ptr->pas.pid.pak_type = MPEG2T_PAS_PAK;
  683.   ptr->pas.pid.next_pid = NULL;
  684.   ptr->pas.pid.pid = 0;
  685.   ptr->pas.pid.collect_pes = 1;
  686.   return (ptr);
  687. }