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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

mpeg3atrack.c：源码内容
  1. #include "libmpeg3.h"
  2. #include "mpeg3protos.h"
  3. #include "mpeg3demux.h"
  4. #include "mp4av.h"
  5. #include <stdlib.h>
  7. static int mpeg3_atrack_get_mp3_info (mpeg3_atrack_t *atrack)
  8. {
  9.   uint8_t hdr[4];
  10.   mpeg3_demuxer_t *demux;
  11.   MP4AV_Mp3Header temp;
  12.   demux = atrack->demuxer;
  14.   hdr[1] = mpeg3demux_read_char(demux);
  15.   do {
  16.     hdr[0] = hdr[1];
  17.     hdr[1] = mpeg3demux_read_char(demux);
  18.   } while (((hdr[0] != 0xff) || 
  19.    ((hdr[1] & 0xe0) != 0xe0)) && 
  20.    !mpeg3demux_eof(demux));
  21.   
  22.   if (mpeg3demux_eof(demux)) return -1;
  24.   hdr[2] = mpeg3demux_read_char(demux);
  25.   hdr[3] = mpeg3demux_read_char(demux);
  26.   temp = MP4AV_Mp3HeaderFromBytes(hdr);
  27.   atrack->sample_rate = MP4AV_Mp3GetHdrSamplingRate(temp);
  28.   atrack->channels = MP4AV_Mp3GetChannels(temp);
  29.   atrack->samples_per_frame = MP4AV_Mp3GetHdrSamplingWindow(temp);
  30.   return 0;
  31. }
  33. static int mpeg3_atrack_get_aac_info (mpeg3_atrack_t *atrack)
  34. {
  35.   uint8_t hdr[16];
  36.   mpeg3_demuxer_t *demux;
  37.   uint16_t hdr_size;
  38.   uint16_t ix;
  40.   demux = atrack->demuxer;
  42.   hdr[1] = mpeg3demux_read_char(demux);
  43.   do {
  44.     hdr[0] = hdr[1];
  45.     hdr[1] = mpeg3demux_read_char(demux);
  46.   } while (((hdr[0] != 0xff) || 
  47.    ((hdr[1] & 0xf0) != 0xf0)) && 
  48.    !mpeg3demux_eof(demux));
  50.   if (mpeg3demux_eof(demux)) return -1;
  52.   hdr_size = MP4AV_AdtsGetHeaderByteSize(hdr);
  53.   if (hdr_size > sizeof(hdr)) return -1;
  54.   for (ix = 2; ix < hdr_size; ix++) {
  55.     hdr[ix] = mpeg3demux_read_char(demux);
  56.   }
  58.   if (mpeg3demux_eof(demux)) return -1;
  59.   
  60.   atrack->sample_rate = MP4AV_AdtsGetSamplingRate(hdr);
  61.   atrack->channels = MP4AV_AdtsGetChannels(hdr);
  62.   atrack->samples_per_frame = 1024; // always the same
  63.   
  64.   return 0;
  65. }
  66. static int mpeg3_ac3_samplerates[] = { 48000, 44100, 32000 };
  68. struct mpeg3_framesize_s
  69. {
  70. unsigned short bit_rate;
  71. unsigned short frm_size[3];
  72. };
  74. static struct mpeg3_framesize_s framesize_codes[] = 
  75. {
  76.       { 32  ,{64   ,69   ,96   } },
  77.       { 32  ,{64   ,70   ,96   } },
  78.       { 40  ,{80   ,87   ,120  } },
  79.       { 40  ,{80   ,88   ,120  } },
  80.       { 48  ,{96   ,104  ,144  } },
  81.       { 48  ,{96   ,105  ,144  } },
  82.       { 56  ,{112  ,121  ,168  } },
  83.       { 56  ,{112  ,122  ,168  } },
  84.       { 64  ,{128  ,139  ,192  } },
  85.       { 64  ,{128  ,140  ,192  } },
  86.       { 80  ,{160  ,174  ,240  } },
  87.       { 80  ,{160  ,175  ,240  } },
  88.       { 96  ,{192  ,208  ,288  } },
  89.       { 96  ,{192  ,209  ,288  } },
  90.       { 112 ,{224  ,243  ,336  } },
  91.       { 112 ,{224  ,244  ,336  } },
  92.       { 128 ,{256  ,278  ,384  } },
  93.       { 128 ,{256  ,279  ,384  } },
  94.       { 160 ,{320  ,348  ,480  } },
  95.       { 160 ,{320  ,349  ,480  } },
  96.       { 192 ,{384  ,417  ,576  } },
  97.       { 192 ,{384  ,418  ,576  } },
  98.       { 224 ,{448  ,487  ,672  } },
  99.       { 224 ,{448  ,488  ,672  } },
  100.       { 256 ,{512  ,557  ,768  } },
  101.       { 256 ,{512  ,558  ,768  } },
  102.       { 320 ,{640  ,696  ,960  } },
  103.       { 320 ,{640  ,697  ,960  } },
  104.       { 384 ,{768  ,835  ,1152 } },
  105.       { 384 ,{768  ,836  ,1152 } },
  106.       { 448 ,{896  ,975  ,1344 } },
  107.       { 448 ,{896  ,976  ,1344 } },
  108.       { 512 ,{1024 ,1114 ,1536 } },
  109.       { 512 ,{1024 ,1115 ,1536 } },
  110.       { 576 ,{1152 ,1253 ,1728 } },
  111.       { 576 ,{1152 ,1254 ,1728 } },
  112.       { 640 ,{1280 ,1393 ,1920 } },
  113.       { 640 ,{1280 ,1394 ,1920 } }
  114. };
  116. /* Audio channel modes */
  117. static short mpeg3_ac3_acmodes[] = {2, 1, 2, 3, 3, 4, 4, 5};
  119. static int mpeg3_atrack_get_ac3_info (mpeg3_atrack_t *atrack)
  120. {
  121.   uint16_t code, mask;
  122.   unsigned int sampling_freq_code, framesize_code;
  123.   unsigned int acmod;
  124.   unsigned int skipbits;
  125.   mpeg3_demuxer_t *demux;
  127.   demux = atrack->demuxer;
  129.   code = mpeg3demux_read_char(demux);
  130.   do {
  131.     code &= 0xff;
  132.     code <<= 8;
  133.     code |= mpeg3demux_read_char(demux);
  134.   } while (!mpeg3demux_eof(demux) && code != MPEG3_AC3_START_CODE);
  135.   if (mpeg3demux_eof(demux)) return -1;
  136.   
  137.   // 2 bytes CRC
  138.   mpeg3demux_read_char(demux);
  139.   mpeg3demux_read_char(demux);
  140.   
  141.   code = mpeg3demux_read_char(demux);
  142.   sampling_freq_code = (code >> 6) & 0x3;
  143.   framesize_code = code & 0x3f;
  145.   // bsid and bsmod
  146.   mpeg3demux_read_char(demux);
  147.   // acmod is 3 bits
  148.   code = mpeg3demux_read_char(demux) << 8;
  149.   code |= mpeg3demux_read_char(demux);
  150.   if (mpeg3demux_eof(demux)) return -1;
  152.   atrack->sample_rate = 
  153.     mpeg3_ac3_samplerates[sampling_freq_code];
  154.   atrack->framesize = 
  155.     2 * framesize_codes[framesize_code].frm_size[sampling_freq_code];
  156.   atrack->samples_per_frame = 1536; // fixed amount from rfc draft
  158.   acmod = (code >> 13) & 0x7;
  159.   atrack->channels = mpeg3_ac3_acmodes[acmod];
  161.   skipbits = 3;
  162.   if ((acmod & 0x1) && (acmod != 1)) {
  163.     skipbits += 2;
  164.   }
  165.   if (acmod & 0x4) skipbits += 2;
  166.   if (acmod == 0x2) skipbits += 2;
  168.   mask = 1 << (15 - skipbits);
  169.   if ((code & mask) != 0) atrack->channels++;
  170.   return 0;
  171. }
  173. static int mpeg3_atrack_suck_frame_info (mpeg3_atrack_t *atrack)
  174. {
  175.   mpeg3_demuxer_t *demux;
  177.   demux = atrack->demuxer;
  178.   if (atrack->format == AUDIO_UNKNOWN) {
  179.     uint16_t code;
  180.     code = mpeg3demux_read_char(demux);
  181.     code <<= 8;
  182.     code |= mpeg3demux_read_char(demux);
  183.     if (code == MPEG3_AC3_START_CODE) {
  184.       atrack->format = AUDIO_AC3;
  185.     } else if ((code & 0xfff8) == 0xfff8) {
  186.       atrack->format = AUDIO_MPEG;
  187.     } else {
  188.       atrack->format = AUDIO_AAC;
  189.     }
  190.     code = mpeg3demux_read_prev_char(demux);
  191.     code = mpeg3demux_read_prev_char(demux);
  192.   }
  193.   
  194.   switch (atrack->format) {
  195.   case AUDIO_PCM:
  196.     atrack->sample_rate = 48000;
  197.     atrack->channels = 2;
  198.     atrack->framesize = 0x7db;
  199.     break;
  200.   case AUDIO_MPEG:
  201.     if (mpeg3_atrack_get_mp3_info(atrack) < 0) return -1;
  202.     break;
  203.   case AUDIO_AC3:
  204.     if (mpeg3_atrack_get_ac3_info(atrack) < 0) return -1;
  205.     break;
  206.   case AUDIO_AAC:
  207.     if (mpeg3_atrack_get_aac_info(atrack) < 0) return -1;
  208.     break;
  209.   }
  210.   mpeg3demux_seek_start(demux);
  211. }
  213. mpeg3_atrack_t* mpeg3_new_atrack(mpeg3_t *file, 
  214. int stream_id, 
  215. int format, 
  216. mpeg3_demuxer_t *demuxer,
  217. int number)
  218. {
  219. mpeg3_atrack_t *new_atrack;
  221. new_atrack = calloc(1, sizeof(mpeg3_atrack_t));
  222. new_atrack->file = file;
  223. new_atrack->channels = 0;
  224. new_atrack->sample_rate = 0;
  225. new_atrack->total_samples = 0;
  226. new_atrack->percentage_seek = -1;
  227. new_atrack->demuxer = mpeg3_new_demuxer(file, 1, 0, stream_id);
  228. if(new_atrack->demuxer) mpeg3demux_copy_titles(new_atrack->demuxer, demuxer);
  229. new_atrack->current_position = 0;
  231. new_atrack->format = format;
  232. if (mpeg3_atrack_suck_frame_info(new_atrack) < 0 ||
  233.     new_atrack->format == AUDIO_UNKNOWN) {
  234. /* Failed */
  235.   mpeg3_delete_atrack(file, new_atrack);
  236.   new_atrack = NULL;
  237. }
  239. //printf("mpeg3 demux length %gn", mpeg3demux_length(new_atrack->demuxer));
  240. // Copy pointers
  241. if(file->sample_offsets)
  242. {
  243. new_atrack->sample_offsets = file->sample_offsets[number];
  244. new_atrack->total_sample_offsets = file->total_sample_offsets[number];
  245. new_atrack->total_frames = new_atrack->total_sample_offsets / 
  246.   new_atrack->samples_per_frame;
  247. } else {
  248.   double time;
  249.   if (new_atrack->samples_per_frame != 0) {
  250.     time = mpeg3demux_length(new_atrack->demuxer);
  252.     time *= new_atrack->sample_rate;
  253.     time /= new_atrack->samples_per_frame;
  254.     new_atrack->total_frames = (uint32_t)time;
  255.     new_atrack->total_sample_offsets = new_atrack->total_frames * 
  256.       new_atrack->samples_per_frame;
  257.     //printf("total frames %dn", new_atrack->total_frames);
  258.   } else {
  259.     new_atrack->total_frames = 0;
  260.     new_atrack->total_sample_offsets = 0;
  261.   }
  262. } 
  263. //printf("total offsets %ldn", new_atrack->total_sample_offsets);
  264. return new_atrack;
  265. }
  267. int mpeg3_delete_atrack(mpeg3_t *file, mpeg3_atrack_t *atrack)
  268. {
  269. if(atrack->demuxer) mpeg3_delete_demuxer(atrack->demuxer);
  270. free(atrack);
  271. return 0;
  272. }
  274. static int mpeg3_atrack_check_length (unsigned char **output, 
  275.       uint32_t cmplen,
  276.       uint32_t *maxlen)
  277. {
  278.   if (cmplen > *maxlen) {
  279.     *output = (unsigned char *)realloc(*output, cmplen);
  280.     if (*output == NULL) return -1;
  281.     *maxlen = cmplen;
  282.   }
  283.   return 0;
  284. }
  285.    
  287. static int mpeg3_atrack_read_pcm_frame (mpeg3_atrack_t *atrack,
  288. unsigned char **output,
  289. uint32_t *len,
  290. uint32_t *maxlen)
  291. {
  292.   uint16_t code;
  293.   mpeg3_demuxer_t *demux;
  294.   uint32_t frame_sample;
  295.   int ret;
  297.   demux = atrack->demuxer;
  299.   code = mpeg3demux_read_char(demux);
  300.   do {
  301.     code <<= 8;
  302.     code |= mpeg3demux_read_char(demux);
  303.   } while (!mpeg3demux_eof(demux) && code != MPEG3_PCM_START_CODE);
  305.   if (mpeg3demux_eof(demux)) return -1;
  307.   frame_sample = (atrack->framesize - 3) / atrack->channels / 2;
  308.   *len = frame_sample * atrack->channels * (sizeof(uint16_t));
  310.   if (mpeg3_atrack_check_length(output, *len, maxlen) < 0) return -1;
  311.  
  312.   ret = mpeg3demux_read_data(demux, *output, *len);
  313.   if (ret != *len) return -1;
  314.   return 0;
  315. }
  317. static int mpeg3_atrack_read_mp3_frame (mpeg3_atrack_t *atrack,
  318. unsigned char **output,
  319. uint32_t *len,
  320. uint32_t *maxlen)
  321. {
  322.   uint8_t code[4];
  323.   mpeg3_demuxer_t *demux;
  324.   uint32_t frame_samples;
  325.   int ret;
  326.   MP4AV_Mp3Header temp;
  327.   int cnt = 1;
  329.   demux = atrack->demuxer;
  331.   code[1] = mpeg3demux_read_char(demux);
  332.   do {
  333.     code[0] = code[1];
  334.     code[1] = mpeg3demux_read_char(demux);
  335.     cnt++;
  336.   } while (!mpeg3demux_eof(demux) && 
  337.    (code[0] != 0xff || ((code[1] & 0xe0) != 0xe0)));
  339.   if (mpeg3demux_eof(demux)) return -1;
  341.   code[2] = mpeg3demux_read_char(demux);
  342.   code[3] = mpeg3demux_read_char(demux);
  344.   temp = MP4AV_Mp3HeaderFromBytes(code);
  345.   *len = MP4AV_Mp3GetFrameSize(temp);
  347.   //printf("header is %08x framesize %dn", temp, *len);
  348.   if (mpeg3_atrack_check_length(output, *len, maxlen) < 0) return -1;
  350.   memcpy(*output, code, 4);
  351.   ret = mpeg3demux_read_data(demux, *output + 4, *len - 4);
  352.   if (ret != *len - 4) return -1;
  353.   return 0;
  354. }
  356. static int mpeg3_atrack_read_aac_frame (mpeg3_atrack_t *atrack,
  357. unsigned char **output, 
  358. uint32_t *len, 
  359. uint32_t *maxlen)
  360. {
  361.   mpeg3_demuxer_t *demux;
  362.   uint16_t hdr_size, ix;
  363.   uint32_t bytes;
  364.   unsigned char hdr[16];
  365.   int ret;
  367.   demux = atrack->demuxer;
  368.   hdr[1] = mpeg3demux_read_char(demux);
  369.   do {
  370.     hdr[0] = hdr[1];
  371.     hdr[1] = mpeg3demux_read_char(demux);
  372.   } while (((hdr[0] != 0xff) || 
  373.    ((hdr[1] & 0xf0) != 0xf0)) && 
  374.    !mpeg3demux_eof(demux));
  375.   bytes = atrack->channels * sizeof(uint16_t) * atrack->samples_per_frame;
  377.   if (mpeg3demux_eof(demux)) return -1;
  379.   hdr_size = MP4AV_AdtsGetHeaderByteSize(hdr);
  380.   if (hdr_size > sizeof(hdr)) return -1;
  381.   for (ix = 2; ix < hdr_size; ix++) {
  382.     hdr[ix] = mpeg3demux_read_char(demux);
  383.   }
  384.   if (mpeg3demux_eof(demux)) return -1;
  386.   bytes = MP4AV_AdtsGetFrameSize(hdr);
  387.   *len = bytes;
  388.   if (mpeg3_atrack_check_length(output, *len, maxlen) < 0) return -1;
  390.   memcpy(*output, hdr, hdr_size);
  391.   ret = mpeg3demux_read_data(demux, *output + hdr_size, *len - hdr_size);
  392.   if (ret != *len - hdr_size) return -1;
  393.   return 0;
  394. }
  396. static int mpeg3_atrack_read_ac3_frame (mpeg3_atrack_t *atrack,
  397. unsigned char **output, 
  398. uint32_t *len, 
  399. uint32_t *maxlen)
  400. {
  401.   uint16_t code;
  402.   mpeg3_demuxer_t *demux;
  403.   int ret;
  405.   demux = atrack->demuxer;
  407.   code = mpeg3demux_read_char(demux);
  408.   do {
  409.     code &= 0xff;
  410.     code <<= 8;
  411.     code |= mpeg3demux_read_char(demux);
  412.   } while (!mpeg3demux_eof(demux) && code != MPEG3_AC3_START_CODE);
  413.   if (mpeg3demux_eof(demux)) return -1;
  415.   *len = atrack->framesize;
  416.   if (mpeg3_atrack_check_length(output, *len, maxlen) < 0) return -1;
  417.   *output[0] = code >> 8;
  418.   *output[1] = code & 0xff;
  419.   ret = mpeg3demux_read_data(demux, *output + 2, *len - 2);
  420.   if (ret != *len - 2) return -1;
  422.   return 0;
  423. }
  425. int mpeg3_atrack_read_frame (mpeg3_atrack_t *atrack, 
  426.      unsigned char **output,
  427.      uint32_t *len,
  428.      uint32_t *maxlen)
  429. {
  430.   if (atrack->percentage_seek >= 0) {
  431.     mpeg3demux_seek_percentage(atrack->demuxer, atrack->percentage_seek);
  432.     atrack->percentage_seek = -1;
  433.   }
  434.   switch (atrack->format) {
  435.   case AUDIO_PCM:
  436.     return (mpeg3_atrack_read_pcm_frame(atrack, output, len, maxlen));
  437.   case AUDIO_MPEG:
  438.     return (mpeg3_atrack_read_mp3_frame(atrack, output, len, maxlen));
  439.   case AUDIO_AC3:
  440.     return (mpeg3_atrack_read_ac3_frame(atrack, output, len, maxlen));
  441.   case AUDIO_AAC:
  442.     return (mpeg3_atrack_read_aac_frame(atrack, output, len, maxlen));
  443.   }
  444.   return -1;
  445. }
  447. int mpeg3atrack_seek_percentage(mpeg3_atrack_t *atrack, double percentage)
  448. {
  449.   atrack->percentage_seek = percentage;
  450.   return 0;
  451. }