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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

isma_rtp_bytestream.cpp：源码内容
  1. /*
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is MPEG4IP.
  13.  * 
  14.  * The Initial Developer of the Original Code is Cisco Systems Inc.
  15.  * Portions created by Cisco Systems Inc. are
  16.  * Copyright (C) Cisco Systems Inc. 2001.  All Rights Reserved.
  17.  * 
  18.  * Contributor(s): 
  19.  *              Bill May        wmay@cisco.com
  20.  */
  22. #include "systems.h"
  23. #include <rtp/rtp.h>
  24. #include <rtp/memory.h>
  25. #include <sdp/sdp.h> // for NTP_TO_UNIX_TIME
  26. #include "bitstream/bitstream.h"
  27. #include "isma_rtp_bytestream.h"
  28. #include "our_config_file.h"
  29. #include <mp4util/mpeg4_audio_config.h>
  30. //#define DEBUG_ISMA_AAC
  32. #ifdef _WIN32
  33. DEFINE_MESSAGE_MACRO(isma_message, "ismartp")
  34. #else
  35. #define isma_message(loglevel, fmt...) message(loglevel, "ismartp", fmt)
  36. #endif
  38. /*
  39.  * Isma rtp bytestream has a potential set of headers at the beginning
  40.  * of each rtp frame.  This can interleave frames in different packets
  41.  */
  42. CIsmaAudioRtpByteStream::CIsmaAudioRtpByteStream (format_list_t *media_fmt,
  43.   fmtp_parse_t *fmtp,
  44.   unsigned int rtp_pt,
  45.   int ondemand,
  46.   uint64_t tps,
  47.   rtp_packet **head, 
  48.   rtp_packet **tail,
  49.   int rtp_seq_set,
  50.   uint16_t rtp_base_seq,
  51.   int rtp_ts_set,
  52.   uint32_t rtp_base_ts,
  53.   int rtcp_received,
  54.   uint32_t ntp_frac,
  55.   uint32_t ntp_sec,
  56.   uint32_t rtp_ts) :
  57.   CRtpByteStreamBase("ismaaac", media_fmt, rtp_pt, ondemand, tps, head, tail, 
  58.      rtp_seq_set, rtp_base_seq, rtp_ts_set, rtp_base_ts,
  59.      rtcp_received, ntp_frac, ntp_sec, rtp_ts)
  60. {
  61. #ifdef ISMA_RTP_DUMP_OUTPUT_TO_FILE
  62.   m_outfile = fopen("isma.aac", "w");
  63. #endif
  64.   m_frame_data_head = NULL;
  65.   m_frame_data_on = NULL;
  66.   m_frame_data_free = NULL;
  67.   isma_frame_data_t *p;
  68.   for (m_frame_data_max = 0; m_frame_data_max < 25; m_frame_data_max++) {
  69.     p = (isma_frame_data_t *)malloc(sizeof(isma_frame_data_t));
  70.     p->frame_data_next = m_frame_data_free;
  71.     m_frame_data_free = p;
  72.   }
  73.   mpeg4_audio_config_t audio_config;
  74.   decode_mpeg4_audio_config(fmtp->config_binary,
  75.     fmtp->config_binary_len,
  76.     &audio_config);
  77.   if (audio_object_type_is_aac(&audio_config)) {
  78.     m_rtp_ts_add = audio_config.codec.aac.frame_len_1024 != 0 ? 1024 : 960;
  79.   } else {
  80.     m_rtp_ts_add = audio_config.codec.celp.samples_per_frame;
  81.     isma_message(LOG_DEBUG, "celp spf is %d", m_rtp_ts_add);
  82.   }
  83.   m_rtp_ts_add = (m_rtp_ts_add * media_fmt->rtpmap->clock_rate) /
  84.     audio_config.frequency;
  85.   isma_message(LOG_DEBUG, 
  86.        "Rtp ts add is %d (%d %d)", m_rtp_ts_add,
  87.        media_fmt->rtpmap->clock_rate, 
  88.        audio_config.frequency);
  89.   m_fmtp = *fmtp;
  90.   m_min_first_header_bits = m_fmtp.size_length + m_fmtp.index_length;
  91.   m_min_header_bits = m_fmtp.size_length + m_fmtp.index_delta_length;
  92.   if (m_fmtp.CTS_delta_length > 0) {
  93.     m_min_header_bits++;
  94.     m_min_first_header_bits++;
  95.   }
  96.   if (m_fmtp.DTS_delta_length > 0) {
  97.     m_min_header_bits++;
  98.     m_min_first_header_bits++;
  99.   }
  100.   isma_message(LOG_DEBUG, "min headers are %d %d", m_min_first_header_bits,
  101.        m_min_header_bits);
  103.   m_min_header_bits += m_fmtp.auxiliary_data_size_length;
  104.   m_min_first_header_bits += m_fmtp.auxiliary_data_size_length;
  105.   m_frag_reass_buffer = NULL;
  106.   m_frag_reass_size_max = 0;
  107. }
  109. CIsmaAudioRtpByteStream::~CIsmaAudioRtpByteStream (void)
  110. {
  111. #ifdef ISMA_RTP_DUMP_OUTPUT_TO_FILE
  112.   fclose(m_outfile);
  113. #endif
  114.   isma_frame_data_t *p;
  115.   
  116.   if (m_frag_reass_buffer != NULL) {
  117.     free(m_frag_reass_buffer);
  118.     m_frag_reass_buffer = NULL;
  119.   }
  120.   if (m_frame_data_on != NULL) {
  121.     m_frame_data_on->frame_data_next = m_frame_data_head;
  122.     m_frame_data_head = m_frame_data_on;
  123.     m_frame_data_on = NULL;
  124.   }
  125.   while (m_frame_data_free != NULL) {
  126.     p = m_frame_data_free;
  127.     m_frame_data_free = p->frame_data_next;
  128.     free(p);
  129.   }
  130.   while (m_frame_data_head != NULL) {
  131.     p = m_frame_data_head;
  132.     // if fragmented frame, free all frag_data
  133.     if (p->is_fragment == 1) {
  134.       isma_frag_data_t * q = p->frag_data;
  135.       while (q != NULL) {
  136. p->frag_data = q->frag_data_next;
  137. free(q);
  138. q = p->frag_data;
  139.       }
  140.     }
  141.     m_frame_data_head = p->frame_data_next;
  142.     free(p);
  143.   }
  144. }
  146. int CIsmaAudioRtpByteStream::insert_frame_data (isma_frame_data_t *frame_data)
  147. {
  148.   SDL_LockMutex(m_rtp_packet_mutex);
  149.   if (m_frame_data_head == NULL) {
  150.     m_frame_data_head = frame_data;
  151.   } else {
  152.     int32_t diff;
  153.     isma_frame_data_t *p, *q;
  154.     q = NULL;
  155.     p = m_frame_data_head;
  157.     do {
  158.       diff = frame_data->rtp_timestamp - p->rtp_timestamp;
  159.       if (diff == 0) {
  160. isma_message(LOG_ERR, "Duplicate timestamp of %x found in RTP packet",
  161.      frame_data->rtp_timestamp);
  162. isma_message(LOG_DEBUG, 
  163.      "Seq number orig %d new %d", 
  164.      p->pak->rtp_pak_seq, frame_data->pak->rtp_pak_seq); 
  165. // if fragmented frame, free all frag_data
  166. if (frame_data->is_fragment == 1) {
  167.   isma_frag_data_t * p = NULL;
  168.   while ((p = frame_data->frag_data) != NULL) {
  169.     frame_data->frag_data = p->frag_data_next;
  170.     free(p);
  171.   }
  172. }
  173. // put frame_data on free list
  174. frame_data->frame_data_next = m_frame_data_free;
  175. m_frame_data_free = frame_data;
  177. SDL_UnlockMutex(m_rtp_packet_mutex);
  178. return 1;
  179.       } else if (diff < 0) {
  180. if (q == NULL) {
  181.   frame_data->frame_data_next = m_frame_data_head;
  182.   m_frame_data_head = frame_data;
  183. } else {
  184.   q->frame_data_next = frame_data;
  185.   frame_data->frame_data_next = p;
  186. }
  187. SDL_UnlockMutex(m_rtp_packet_mutex);
  188. return 0;
  189.       }
  190.       q = p;
  191.       p = p->frame_data_next;
  192.     } while (p != NULL);
  193.     // insert at end;
  194.     q->frame_data_next = frame_data;
  196.   }
  197.   SDL_UnlockMutex(m_rtp_packet_mutex);
  198.   return 0;
  199. }
  201. void CIsmaAudioRtpByteStream::get_au_header_bits (void)
  202. {
  203.   uint32_t temp;
  204.   if (m_fmtp.CTS_delta_length > 0) {
  205.     m_header_bitstream.getbits(1, &temp);
  206.     if (temp > 0) {
  207.       m_header_bitstream.getbits(m_fmtp.CTS_delta_length, &temp);
  208.     }
  209.   }
  210.   if (m_fmtp.DTS_delta_length > 0) {
  211.     m_header_bitstream.getbits(1, &temp);
  212.     if (temp > 0) {
  213.       m_header_bitstream.getbits(m_fmtp.DTS_delta_length, &temp);
  214.     }
  215.   }
  216. }
  218. // check where need to lock 
  219. void CIsmaAudioRtpByteStream::cleanup_frag (isma_frame_data_t * frame_data)
  220. {
  221.   // free all frag_data for this frame
  222.   isma_frag_data_t * p = NULL;
  223.   while ((p = frame_data->frag_data) != NULL) {
  224.     frame_data->frag_data = p->frag_data_next;
  225.     free(p);
  226.   } 
  227.   // now put frame_data back on free list
  228.   SDL_LockMutex(m_rtp_packet_mutex);
  229.   frame_data->frame_data_next = m_frame_data_free;
  230.   m_frame_data_free = frame_data;
  231.   SDL_UnlockMutex(m_rtp_packet_mutex);
  232.   return;
  233. }
  235. // Frame is fragmented.
  236. // Process next RTP paks until have the entire frame.
  237. // Paks will be in order in the queue, but maybe some missing?
  238. // So if process pkt w/ Mbit set (last of fragm) and total < frameLength
  239. // ignore pkt.
  240. // Insert frame data only after got all fragments for the frame.
  241. int CIsmaAudioRtpByteStream::process_fragment (rtp_packet *pak, 
  242.        isma_frame_data_t *frame_data)
  243. {
  244.   uint16_t seq = pak->rtp_pak_seq; 
  245.   uint32_t ts = pak->rtp_pak_ts;
  246.   isma_frag_data_t *cur = NULL;
  247.   int read_mBit = 0;
  248.   uint32_t total_len = 0; 
  249.   frame_data->is_fragment = 1;
  250.   do {
  251.     if (read_mBit == 1) {
  252.       // get rid of frame_data - last frag seen but total length wrong
  253.       cleanup_frag(frame_data);
  254.       isma_message(LOG_ERR, "Error processing frag: early mBit");
  255.       return (1); 
  256.     }
  257.     if (pak == NULL) {
  258.       cleanup_frag(frame_data);
  259.       isma_message(LOG_ERR, "Error processing frag: not enough packets");
  260.       return (1);
  261.     }
  262.     // check if ts and rtp seq numbers are ok, and lengths match
  263.     if (ts != pak->rtp_pak_ts) {
  264.       cleanup_frag(frame_data);
  265.       isma_message(LOG_ERR, 
  266.    "Error processing frag: wrong ts: ts= %x, pak->ts = %x", 
  267.    ts, pak->rtp_pak_ts);
  268.       return (1);
  269.     }
  270.     if (seq != pak->rtp_pak_seq) {
  271.       cleanup_frag(frame_data);
  272.       isma_message(LOG_ERR, "Error processing frag: wrong seq num");
  273.       return (1);
  274.     }
  275.     // insert fragment info
  276.     isma_frag_data_t *p = (isma_frag_data_t *)
  277.       malloc(sizeof(isma_frag_data_t));
  278.     if (p == NULL) {
  279.       isma_message(LOG_ERR, "Error processing frag: can't malloc");
  280.       remove_packet_rtp_queue(pak, 0);
  281.       return (1);
  282.     }
  283.     if (cur == NULL) {
  284.       frame_data->frag_data = p;
  285.       cur = p;
  286.     } else {
  287.       cur->frag_data_next = p;
  288.       cur = p;
  289.     }
  290.     cur->frag_data_next = NULL;
  291.     cur->pak = pak; 
  292.     // length in bits
  293.     uint16_t header_len = ntohs(*(unsigned short *)pak->rtp_data);
  294.     m_header_bitstream.init(&pak->rtp_data[sizeof(uint16_t)], header_len);
  295.     // frag_ptr should just point to beginning of data in pkt
  296.     uint32_t header_len_bytes = ((header_len + 7) / 8) + sizeof(uint16_t);
  297.     cur->frag_ptr =  &pak->rtp_data[header_len_bytes];
  298.     cur->frag_len = pak->rtp_data_len - header_len_bytes;
  299.     // if aux data, move frag pointer
  300.     if (m_fmtp.auxiliary_data_size_length > 0) {
  301.       m_header_bitstream.byte_align();
  302.       uint32_t aux_len;
  303.       m_header_bitstream.getbits(m_fmtp.auxiliary_data_size_length, &aux_len);
  304.       aux_len = (aux_len + 7) / 8;
  305.       cur->frag_ptr += aux_len;
  306.       cur->frag_len -= aux_len;
  307.     }
  308.     total_len += cur->frag_len;
  309. #ifdef DEBUG_ISMA_RTP_FRAGS
  310.     isma_message(LOG_DEBUG, 
  311.  "rtp seq# %d, fraglen: %d, ts: %x", 
  312.  pak->seq, cur->frag_len, pak->ts);
  313. #endif
  314.     seq = pak->rtp_pak_seq + 1;
  315.     if (pak->rtp_pak_m) 
  316.       read_mBit = 1;
  317.     remove_packet_rtp_queue(pak, 0);
  318.     pak = m_head; // get next pkt in the queue
  319.   } while (total_len < frame_data->frame_len);
  321.   // insert frame and return
  322.   int error = insert_frame_data(frame_data);
  323.   frame_data->last_in_pak = 1; // only one frame in pak
  324.   // no need to remove pkt from queue, done at the end of do-while
  325.   return (error);
  326. }
  328. void CIsmaAudioRtpByteStream::process_packet_header (void)
  329. {
  330.   rtp_packet *pak;
  331.   uint32_t frame_len;
  332.   uint16_t header_len;
  333.   uint32_t retvalue;
  335.   pak = m_head;
  336.   if (pak == NULL) {
  337.     return;
  338.   }
  339. #ifdef DEBUG_ISMA_AAC
  340.   isma_message(LOG_DEBUG, 
  341.        "processing pak seq %d ts %x len %d", 
  342.        pak->rtp_pak_seq, pak->rtp_pak_ts, pak->rtp_data_len);
  343. #endif
  344.   // This pak has not had it's header processed
  345.   // length in bytes
  346.   if (pak->rtp_data_len == 0) {
  347.     remove_packet_rtp_queue(pak, 1);
  348.     isma_message(LOG_ERR, "RTP audio packet with data length of 0");
  349.     return;
  350.   }
  352.   header_len = ntohs(*(unsigned short *)pak->rtp_data);
  353.   if (header_len < m_min_first_header_bits) {
  354.     // bye bye, frame...
  355.     remove_packet_rtp_queue(pak, 1);
  356.     isma_message(LOG_ERR, "ISMA rtp - header len %d less than min %d", 
  357.  header_len, m_min_first_header_bits);
  358.     return;
  359.   }
  361.   m_header_bitstream.init(&pak->rtp_data[sizeof(uint16_t)],
  362.   header_len);
  363.   if (m_header_bitstream.getbits(m_fmtp.size_length, &frame_len) != 0) 
  364.     return;
  365.   m_header_bitstream.getbits(m_fmtp.index_length, &retvalue);
  366.   get_au_header_bits();
  367. #ifdef DEBUG_ISMA_AAC
  368.   uint64_t wrap_offset = m_wrap_offset;
  369.   uint64_t msec = rtp_ts_to_msec(pak->rtp_pak_ts, wrap_offset);
  370.   isma_message(LOG_DEBUG, 
  371.        "1st - header len %u frame len %u ts %x %llu", 
  372.        header_len, frame_len, pak->rtp_pak_ts, msec);
  373. #endif
  374.   if (frame_len == 0) {
  375.     remove_packet_rtp_queue(pak, 1);
  376.     return;
  377.   }
  378.   uint8_t *frame_ptr;
  379.   isma_frame_data_t *frame_data;
  380.   uint32_t ts;
  381.   ts = pak->rtp_pak_ts;
  382.   frame_data = get_frame_data();
  383.   frame_data->pak = pak;
  384.   // frame pointer is after header_len + header_len size.  Header_len
  385.   // is in bits - add 7, divide by 8 to get padding correctly.
  386.   frame_data->frame_ptr = &pak->rtp_data[((header_len + 7) / 8) 
  387.     + sizeof(uint16_t)];
  388.   frame_data->frame_len = frame_len;
  389.   frame_data->rtp_timestamp = ts;
  391.   // Check if frame is fragmented
  392.   // frame_len plus the length of the 2 headers
  393.   int frag_check = frame_len + sizeof(uint16_t);
  394.   frag_check += m_fmtp.size_length / 8;
  395.   if ((m_fmtp.size_length % 8) != 0) frag_check++;
  396.   if (frag_check > pak->rtp_data_len) {
  397. #ifdef DEBUG_ISMA_AAC
  398.     isma_message(LOG_DEBUG, "Frame is fragmented");
  399. #endif
  400.     frame_data->is_fragment = 1;
  401.     int err = process_fragment(pak, frame_data);
  402.     if (err == 1)
  403.       isma_message(LOG_ERR, "Error in processing the fragment");
  404.     return; 
  405.   }
  406.   else {
  407. #ifdef DEBUG_ISMA_AAC
  408.     isma_message(LOG_DEBUG, "Frame is not fragmented");
  409. #endif
  410.     frame_data->is_fragment = 0;
  411.     frame_data->frag_data = NULL;
  412.   }
  413.   int error = insert_frame_data(frame_data);
  414.   frame_ptr = frame_data->frame_ptr + frame_data->frame_len;
  415.   while (m_header_bitstream.bits_remain() >= m_min_header_bits) {
  416.     uint32_t stride;
  417.     m_header_bitstream.getbits(m_fmtp.size_length, &frame_len);
  418.     m_header_bitstream.getbits(m_fmtp.index_delta_length, &stride);
  419.     get_au_header_bits();
  420.     ts += (m_rtp_ts_add * (1 + stride));
  421. #ifdef DEBUG_ISMA_AAC
  422.     wrap_offset = m_wrap_offset;
  423.     msec = rtp_ts_to_msec(ts, wrap_offset);
  424.     isma_message(LOG_DEBUG, 
  425.  "Stride %d len %d ts %x %llu", 
  426.  stride, frame_len, ts, msec);
  427. #endif
  428.     frame_data = get_frame_data();
  429.     frame_data->pak = pak;
  430.     frame_data->is_fragment = 0;
  431.     frame_data->frag_data = NULL;
  432.     frame_data->frame_ptr = frame_ptr;
  433.     frame_data->frame_len = frame_len;
  434.     frame_ptr += frame_len;
  435.     frame_data->rtp_timestamp = ts;
  436.     error |= insert_frame_data(frame_data);
  437.   }
  438.   if (error == 0 && frame_data != NULL) { 
  439.     frame_data->last_in_pak = 1;
  440.   }
  441.   else {
  442.     isma_frame_data_t *p, *last = NULL;
  443.     p = m_frame_data_head;
  444.     while (p != NULL) {
  445.       if (p->pak == pak) last = p;
  446.       p = p->frame_data_next;
  447.     }
  448.     if (last != NULL) {
  449.       last->last_in_pak = 1;
  450.       isma_message(LOG_WARNING, "error at end - marked ts %x", last->rtp_timestamp);
  451.     } else {
  452.       // Didn't find pak in list.  Weird
  453.       isma_message(LOG_ERR, 
  454.    "Decoded packet with RTP timestamp %x and didn't"
  455.    "see any good frames", pak->rtp_pak_ts);
  456.       remove_packet_rtp_queue(pak, 1);
  457.       return;
  458.     }
  459.   }
  460.   if (m_fmtp.auxiliary_data_size_length > 0) {
  461.     m_header_bitstream.byte_align();
  462.     uint32_t aux_len;
  463.     m_header_bitstream.getbits(m_fmtp.auxiliary_data_size_length, &aux_len);
  464.     aux_len = (aux_len + 7) / 8;
  465. #ifdef DEBUG_ISMA_AAC
  466.     isma_message(LOG_DEBUG, "Adding %d bytes for aux data size", aux_len);
  467. #endif
  468.     isma_frame_data_t *p;
  469.     p = m_frame_data_head;
  470.     while (p != NULL) {
  471.       if (p->pak == pak) {
  472. p->frame_ptr += aux_len;
  473.       }
  474.       p = p->frame_data_next;
  475.     }
  476.   }
  477.     
  478.   remove_packet_rtp_queue(pak, 0);
  479. }
  481. uint64_t CIsmaAudioRtpByteStream::start_next_frame (uint8_t **buffer, 
  482.     uint32_t *buflen,
  483.     void **userdata)
  484. {
  485.   uint64_t timetick;
  487.   if (m_frame_data_on != NULL) {
  488.     uint32_t next_ts;
  489. #ifdef DEBUG_ISMA_AAC
  490.     isma_message(LOG_DEBUG, "Advancing to next pak data - old ts %x", 
  491.  m_frame_data_on->rtp_timestamp);
  492. #endif
  493.     if (m_frame_data_on->last_in_pak != 0) {
  494.       // We're done with all the data in this packet - get rid
  495.       // of the rtp packet.
  496.       if (m_frame_data_on->is_fragment == 1) {
  497. // if fragmented, need to get rid of all paks pointed to
  498. isma_frag_data_t *q =  m_frame_data_on->frag_data;
  499. while (q != NULL) {
  500.   rtp_packet *pak = q->pak;
  501.   q->pak = NULL;
  502.   if (pak != NULL)
  503.     xfree(pak);
  504.   q = q->frag_data_next;
  505. #ifdef DEBUG_ISMA_AAC
  506.   isma_message(LOG_DEBUG, "removing pak - frag %d", pak->rtp_pak_seq);
  507. #endif
  508. }
  509.       } else {
  510. rtp_packet *pak = m_frame_data_on->pak;
  511. m_frame_data_on->pak = NULL;
  512. xfree(pak);
  513. #ifdef DEBUG_ISMA_AAC
  514. isma_message(LOG_DEBUG, "removing pak %d", pak->rtp_pak_seq);
  515. #endif
  516.       }
  517.     }
  518.     /*
  519.      * Remove the frame data head pointer, and put it on the free list
  520.      */
  521.     isma_frame_data_t *p = NULL;
  522.     SDL_LockMutex(m_rtp_packet_mutex);
  523.     p = m_frame_data_on;
  524.     m_frame_data_on = NULL;
  525.     next_ts = p->rtp_timestamp;
  526.     p->frame_data_next = m_frame_data_free;
  527.     m_frame_data_free = p;
  528.     // free all frag_data for this frame
  529.     if (p->is_fragment == 1) {
  530.       isma_frag_data_t * q = p->frag_data;
  531.       while (q != NULL) {
  532. p->frag_data = q->frag_data_next;
  533. free(q);
  534. q = p->frag_data;
  535.       } 
  536.     }
  537.     SDL_UnlockMutex(m_rtp_packet_mutex);
  539.     /* 
  540.      * Now, look for the next timestamp - process a bunch of new
  541.      * rtp packets, if we have to...
  542.      */
  543.     next_ts += m_rtp_ts_add;
  544.     if (m_frame_data_head == NULL ||
  545. m_frame_data_head->rtp_timestamp != next_ts) {
  546.       // process next pak in list.  Process until next timestamp is found, 
  547.       // or 500 msec worth of data is found (in which case, go with first)
  548.       do {
  549. process_packet_header();
  550.       } while (m_head != NULL && 
  551.        ((m_frame_data_head == NULL) || 
  552. (m_frame_data_head->rtp_timestamp != next_ts)) &&  
  553.        (m_frame_data_free != NULL));
  554.     }
  555. #ifdef DEBUG_ISMA_AAC
  556.     else {
  557.       // m_frame_data_head is correct
  558.       isma_message(LOG_DEBUG, "frame_data_head is correct");
  559.     }
  560. #endif
  561.   } else {
  562.     // first time.  Process a bunch of packets, go with first one...
  563.     // asdf - will want to eventually add code to drop the first couple
  564.     // of packets if they're not consecutive.
  565.     do {
  566.       process_packet_header();
  567.     } while (m_frame_data_free != NULL);
  568.   }
  569.   /*
  570.    * Init up the offsets
  571.    */
  572.   if (m_frame_data_head != NULL) {
  573.     SDL_LockMutex(m_rtp_packet_mutex);
  574.     m_frame_data_on = m_frame_data_head;
  575.     m_frame_data_head = m_frame_data_head->frame_data_next;
  576.     SDL_UnlockMutex(m_rtp_packet_mutex);
  578.     if (m_frame_data_on->is_fragment == 1) {   
  580.       m_frag_reass_size = 0;
  581.       isma_frag_data_t *ptr;
  582.       ptr = m_frame_data_on->frag_data;
  583.       while (ptr != NULL) {
  584. if (m_frag_reass_size + ptr->frag_len > m_frag_reass_size_max) {
  585.   m_frag_reass_size_max += max(4096, ptr->frag_len);
  586.   m_frag_reass_buffer = (uint8_t *)realloc(m_frag_reass_buffer, 
  587.  m_frag_reass_size_max);
  588. }
  589. memmove(m_frag_reass_buffer + m_frag_reass_size, 
  590. ptr->frag_ptr,
  591. ptr->frag_len);
  592. m_frag_reass_size += ptr->frag_len;
  593. ptr = ptr->frag_data_next;
  594.       }
  595.       *buffer = m_frag_reass_buffer;
  596.       *buflen = m_frag_reass_size;
  597.     } else { 
  598.       *buffer = m_frame_data_on->frame_ptr;
  599.       *buflen = m_frame_data_on->frame_len;
  600.     }
  601.   } else {
  602.     *buffer = NULL;
  603.   }
  604. #ifdef ISMA_RTP_DUMP_OUTPUT_TO_FILE
  605.   if (*buffer != NULL) {
  606.     fwrite(*buffer, *buflen,  1, m_outfile);
  607.   }
  608. #endif
  609.   timetick = rtp_ts_to_msec(m_frame_data_on != NULL ? 
  610.     m_frame_data_on->rtp_timestamp : m_ts, 
  611.     m_wrap_offset);
  612.   if (m_frame_data_on != NULL)
  613.     m_ts =  m_frame_data_on->rtp_timestamp;
  614.   // We're going to have to handle wrap better...
  615. #ifdef DEBUG_ISMA_AAC
  616.   isma_message(LOG_DEBUG, "start next frame %p %d ts %x "LLU, 
  617.        *buffer, *buflen, m_ts, timetick);
  618. #endif
  619.   return (timetick);
  620. }
  622. void CIsmaAudioRtpByteStream::used_bytes_for_frame (uint32_t bytes)
  623. {
  624. }
  626. void CIsmaAudioRtpByteStream::flush_rtp_packets (void)
  627. {
  628.   isma_frame_data_t *p;
  629.   SDL_LockMutex(m_rtp_packet_mutex);
  630.   if (m_frame_data_on != NULL) {
  631.     m_frame_data_on->frame_data_next = m_frame_data_head;
  632.     m_frame_data_head = m_frame_data_on;
  633.     m_frame_data_on = NULL;
  634.   }
  635.   if (m_frame_data_head != NULL) {
  636.     p = m_frame_data_head;
  637.     while (p->frame_data_next != NULL) {
  638. #ifdef DEBUG_ISMA_AAC
  639.       isma_message(LOG_DEBUG, "reset removing pak %d", p->pak->rtp_pak_seq);
  640. #endif
  641.       if (p->last_in_pak != 0) {
  642. if (p->is_fragment == 1) {
  643.   // get rid of frag data 
  644.   isma_frag_data_t * q = NULL;
  645.   while ((q = p->frag_data) != NULL) {
  646.     p->frag_data = q->frag_data_next;
  647.     free(q);
  648.   } 
  649. }
  650. xfree(p->pak);
  651.       }
  652.       p = p->frame_data_next;
  653.     }
  654.     p->frame_data_next = m_frame_data_free;
  655.     m_frame_data_free = m_frame_data_head;
  656.     m_frame_data_head = NULL;
  657.   }
  658.   SDL_UnlockMutex(m_rtp_packet_mutex);
  659.   CRtpByteStreamBase::flush_rtp_packets();
  660. }
  662. void CIsmaAudioRtpByteStream::reset (void)
  663. {
  664.   isma_message(LOG_INFO, "Hit isma rtp reset");
  665.   CRtpByteStreamBase::reset();
  666. }
  669. int CIsmaAudioRtpByteStream::have_no_data (void)
  670. {
  671.   return (m_head == NULL && m_frame_data_head == NULL);
  672. }