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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

mpeg3demux.c：源码内容
  1. #include "libmpeg3.h"
  2. #include "mpeg3io.h"
  3. #include "mpeg3protos.h"
  4. #include "workarounds.h"
  6. #include <errno.h>
  7. #include <math.h>
  8. #include <stdlib.h>
  9. #include <string.h>
  11. #define ABS(x) ((x) >= 0 ? (x) : -(x))
  13. /* Don't advance pointer */
  14. static __inline unsigned char packet_next_char(mpeg3_demuxer_t *demuxer)
  15. {
  16. //printf(__FUNCTION__ " calledn");
  17. return demuxer->raw_data[demuxer->raw_offset];
  18. }
  20. /* Advance pointer */
  21. static unsigned char packet_read_char(mpeg3_demuxer_t *demuxer)
  22. {
  23. unsigned char result = demuxer->raw_data[demuxer->raw_offset++];
  24. //printf(__FUNCTION__ " calledn");
  25. return result;
  26. }
  28. static __inline unsigned int packet_read_int16(mpeg3_demuxer_t *demuxer)
  29. {
  30. unsigned int a, b, result;
  31. //printf(__FUNCTION__ " calledn");
  32. a = demuxer->raw_data[demuxer->raw_offset++];
  33. b = demuxer->raw_data[demuxer->raw_offset++];
  34. result = (a << 8) | b;
  36. return result;
  37. }
  39. static __inline unsigned int packet_next_int24(mpeg3_demuxer_t *demuxer)
  40. {
  41. unsigned int a, b, c, result;
  42. //printf(__FUNCTION__ " calledn");
  43. a = demuxer->raw_data[demuxer->raw_offset];
  44. b = demuxer->raw_data[demuxer->raw_offset + 1];
  45. c = demuxer->raw_data[demuxer->raw_offset + 2];
  46. result = (a << 16) | (b << 8) | c;
  48. return result;
  49. }
  51. static __inline unsigned int packet_read_int24(mpeg3_demuxer_t *demuxer)
  52. {
  53. unsigned int a, b, c, result;
  54. //printf(__FUNCTION__ " calledn");
  55. a = demuxer->raw_data[demuxer->raw_offset++];
  56. b = demuxer->raw_data[demuxer->raw_offset++];
  57. c = demuxer->raw_data[demuxer->raw_offset++];
  58. result = (a << 16) | (b << 8) | c;
  60. return result;
  61. }
  63. static __inline unsigned int packet_read_int32(mpeg3_demuxer_t *demuxer)
  64. {
  65. unsigned int a, b, c, d, result;
  66. //printf(__FUNCTION__ " calledn");
  67. a = demuxer->raw_data[demuxer->raw_offset++];
  68. b = demuxer->raw_data[demuxer->raw_offset++];
  69. c = demuxer->raw_data[demuxer->raw_offset++];
  70. d = demuxer->raw_data[demuxer->raw_offset++];
  71. result = (a << 24) | (b << 16) | (c << 8) | d;
  73. return result;
  74. }
  76. static __inline unsigned int packet_skip(mpeg3_demuxer_t *demuxer, long length)
  77. {
  78. //printf(__FUNCTION__ " calledn");
  79. demuxer->raw_offset += length;
  80. return 0;
  81. }
  83. static int get_adaptation_field(mpeg3_demuxer_t *demuxer)
  84. {
  85. long length;
  86. int pcr_flag;
  88. demuxer->adaptation_fields++;
  89. /* get adaptation field length */
  90. length = packet_read_char(demuxer);
  92. if(length > 0)
  93. {
  94. /* get first byte */
  95.    pcr_flag = (packet_read_char(demuxer) >> 4) & 1;           
  97. if(pcr_flag)
  98. {
  99.      unsigned long clk_ref_base = packet_read_int32(demuxer);
  100.      unsigned int clk_ref_ext = packet_read_int16(demuxer);
  102. if (clk_ref_base > 0x7fffffff)
  103. {   /* correct for invalid numbers */
  104. clk_ref_base = 0;               /* ie. longer than 32 bits when multiplied by 2 */
  105. clk_ref_ext = 0;                /* multiplied by 2 corresponds to shift left 1 (<<=1) */
  106. }
  107. else 
  108. {
  109. clk_ref_base <<= 1; /* Create space for bit */
  110. clk_ref_base |= (clk_ref_ext >> 15);          /* Take bit */
  111. clk_ref_ext &= 0x01ff;                        /* Only lower 9 bits */
  112. }
  113. demuxer->time = ((double)clk_ref_base + clk_ref_ext / 300) / 90000;
  114.      if(length) packet_skip(demuxer, length - 7);
  115. }
  116. else
  117. packet_skip(demuxer, length - 1);
  118. }
  120. return 0;
  121. }
  123. static int get_program_association_table(mpeg3_demuxer_t *demuxer)
  124. {
  125. demuxer->program_association_tables++;
  126. demuxer->table_id = packet_read_char(demuxer);
  127. demuxer->section_length = packet_read_int16(demuxer) & 0xfff;
  128. demuxer->transport_stream_id = packet_read_int16(demuxer);
  129. packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
  130. return 0;
  131. }
  133. static int get_data_buffer(mpeg3_demuxer_t *demuxer)
  134. {
  135. while(demuxer->raw_offset < demuxer->raw_size && 
  136. demuxer->data_size < MPEG3_RAW_SIZE)
  137. {
  138. demuxer->data_buffer[demuxer->data_size++] = 
  139. demuxer->raw_data[demuxer->raw_offset++];
  140. }
  141. return 0;
  142. }
  144. static int get_pes_packet_header(mpeg3_demuxer_t *demuxer, unsigned long *pts, unsigned long *dts)
  145. {
  146. unsigned int pes_header_bytes = 0;
  147. unsigned int pts_dts_flags;
  148. int pes_header_data_length;
  150. /* drop first 8 bits */
  151. packet_read_char(demuxer);  
  152. pts_dts_flags = (packet_read_char(demuxer) >> 6) & 0x3;
  153. pes_header_data_length = packet_read_char(demuxer);
  155. /* Get Presentation Time stamps and Decoding Time Stamps */
  156. if(pts_dts_flags == 2)
  157. {
  158. *pts = (packet_read_char(demuxer) >> 1) & 7;  /* Only low 4 bits (7==1111) */
  159. *pts <<= 15;
  160. *pts |= (packet_read_int16(demuxer) >> 1);
  161. *pts <<= 15;
  162. *pts |= (packet_read_int16(demuxer) >> 1);
  163. pes_header_bytes += 5;
  164. }
  165. else if(pts_dts_flags == 3)
  166. {      
  167. *pts = (packet_read_char(demuxer) >> 1) & 7;  /* Only low 4 bits (7==1111) */
  168. *pts <<= 15;
  169. *pts |= (packet_read_int16(demuxer) >> 1);
  170. *pts <<= 15;
  171. *pts |= (packet_read_int16(demuxer) >> 1);
  172. *dts = (packet_read_char(demuxer) >> 1) & 7;  /* Only low 4 bits (7==1111) */
  173. *dts <<= 15;
  174. *dts |= (packet_read_int16(demuxer) >> 1);
  175. *dts <<= 15;
  176. *dts |= (packet_read_int16(demuxer) >> 1);
  177. pes_header_bytes += 10;
  178.   }
  180. demuxer->time = (double)*pts / 90000;
  181. //printf("get_pes_packet_header %fn", demuxer->time);
  182. /* extract other stuff here! */
  183. packet_skip(demuxer, pes_header_data_length - pes_header_bytes);
  184. return 0;
  185. }
  187. static int get_unknown_data(mpeg3_demuxer_t *demuxer)
  188. {
  189. packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
  190. return 0;
  191. }
  193. // Combine the pid and the stream id into one unit
  194. #define CUSTOM_ID(pid, stream_id) (((pid << 8) | stream_id) & 0xffff)
  197. static int get_pes_packet_data(mpeg3_demuxer_t *demuxer, unsigned int stream_id)
  198. {
  199. unsigned long pts = 0, dts = 0;
  200. get_pes_packet_header(demuxer, &pts, &dts);
  202. //printf("get_pes_packet_data %xn", CUSTOM_ID(demuxer->pid, stream_id));
  203. if(stream_id == 0xbd)
  204. {
  205. // Don't know if the next byte is the true stream id like in program stream
  206. stream_id = 0x0;
  208. if(demuxer->read_all)
  209. demuxer->astream_table[CUSTOM_ID(demuxer->pid, stream_id)] = AUDIO_AC3;
  210. if(demuxer->astream == -1)
  211.     demuxer->astream = CUSTOM_ID(demuxer->pid, stream_id);
  213.      if(CUSTOM_ID(demuxer->pid, stream_id) == demuxer->astream && 
  214. demuxer->do_audio)
  215. {
  216. // get_pes_packet_header(demuxer, &pts, &dts);
  217. demuxer->pes_audio_time = pts;
  218. demuxer->audio_pid = demuxer->pid;
  219. return get_data_buffer(demuxer);
  220.      }
  221. }
  222. else
  223. if((stream_id >> 4) == 12 || (stream_id >> 4) == 13)
  224. {
  225. /* Just pick the first available stream if no ID is set */
  226. //printf("get_pes_packet_data audio %xn", stream_id);
  227. if(demuxer->read_all)
  228. demuxer->astream_table[CUSTOM_ID(demuxer->pid, stream_id)] = AUDIO_MPEG;
  229. if(demuxer->astream == -1)
  230.     demuxer->astream = CUSTOM_ID(demuxer->pid, stream_id);
  232.      if(CUSTOM_ID(demuxer->pid, stream_id) == demuxer->astream && 
  233. demuxer->do_audio)
  234. {
  235. // get_pes_packet_header(demuxer, &pts, &dts);
  236. demuxer->pes_audio_time = pts;
  237. demuxer->audio_pid = demuxer->pid;
  238. return get_data_buffer(demuxer);
  239.      }
  240. }
  241. else 
  242. if((stream_id >> 4) == 14)
  243. {
  244. //printf("get_pes_packet_data video %xn", stream_id);
  245. /* Just pick the first available stream if no ID is set */
  246. if(demuxer->read_all)
  247. demuxer->vstream_table[CUSTOM_ID(demuxer->pid, stream_id)] = 1;
  248. else
  249. if(demuxer->vstream == -1)
  250. demuxer->vstream = (CUSTOM_ID(demuxer->pid, stream_id));
  252. if(CUSTOM_ID(demuxer->pid, stream_id) == demuxer->vstream && 
  253. demuxer->do_video)
  254. {
  255. // get_pes_packet_header(demuxer, &pts, &dts);
  256. demuxer->pes_video_time = pts;
  257. demuxer->video_pid = demuxer->pid;
  258. return get_data_buffer(demuxer);
  259. }
  260. }
  261. else 
  262. {
  263. return get_unknown_data(demuxer);
  264. }
  266. packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
  268. return 0;
  269. }
  271. static int get_pes_packet(mpeg3_demuxer_t *demuxer)
  272. {
  273. unsigned int stream_id;
  275. demuxer->pes_packets++;
  276. /* Skip startcode */
  277. packet_read_int24(demuxer);
  278. stream_id = packet_read_char(demuxer);
  279. /* Skip pes packet length */
  280. packet_read_int16(demuxer);
  282. if(stream_id != MPEG3_PRIVATE_STREAM_2 && 
  283. stream_id != MPEG3_PADDING_STREAM)
  284. {
  285. return get_pes_packet_data(demuxer, stream_id);
  286. }
  287. else
  288. if(stream_id == MPEG3_PRIVATE_STREAM_2)
  289. {
  290. /* Dump private data! */
  291. fprintf(stderr, "stream_id == MPEG3_PRIVATE_STREAM_2n");
  292. packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
  293. return 0;
  294. }
  295. else
  296. if(stream_id == MPEG3_PADDING_STREAM)
  297. {
  298. packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
  299. return 0;
  300. }
  301. else
  302. {
  303.      fprintf(stderr, "unknown stream_id in pes packet");
  304. return 1;
  305. }
  306. return 0;
  307. }
  309. static int get_payload(mpeg3_demuxer_t *demuxer)
  310. {
  311. //printf("get_payload 1 %x %dn", demuxer->pid, demuxer->payload_unit_start_indicator);
  312. if(demuxer->payload_unit_start_indicator)
  313. {
  314.      if(demuxer->pid==0) get_program_association_table(demuxer);
  315.      else 
  316. if(packet_next_int24(demuxer) == MPEG3_PACKET_START_CODE_PREFIX) get_pes_packet(demuxer);
  317.      else 
  318. packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
  319. }
  320. else
  321. {
  322. //printf("get_payload 2n");
  323.      if(demuxer->pid == demuxer->audio_pid && demuxer->do_audio)
  324. {
  325. get_data_buffer(demuxer);
  326. }
  327.      else 
  328. if(demuxer->pid == demuxer->video_pid && demuxer->do_video)
  329. {
  330. get_data_buffer(demuxer);
  331. }
  332.      else 
  333. packet_skip(demuxer, demuxer->raw_size - demuxer->raw_offset);
  334. }
  335. return 0;
  336. }
  338. /* Read a transport packet */
  339. static int read_transport(mpeg3_demuxer_t *demuxer)
  340. {
  341. mpeg3_t *file = (mpeg3_t*)demuxer->file;
  342. mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
  343. int result = 0;
  344. unsigned int bits;
  345. int table_entry;
  347. //printf("read_transport 1 %dn", file->packet_size);
  348. /* Packet size is known for transport streams */
  349. demuxer->raw_size = file->packet_size;
  350. demuxer->raw_offset = 0;
  352. if(result)
  353. {
  354. perror("read_transport");
  355. return 1;
  356. }
  358. //printf("read transport 1n");
  359. // Search for Sync byte */
  360. do
  361. {
  362. bits = mpeg3io_read_char(title->fs);
  363. }while(!mpeg3io_eof(title->fs) && !result && bits != MPEG3_SYNC_BYTE);
  365. //printf("read transport 2 bits=%x tell=%llx packet_size=%xn", bits, mpeg3io_tell(title->fs), file->packet_size);
  367. if(bits == MPEG3_SYNC_BYTE && !result)
  368. {
  369. demuxer->raw_data[0] = MPEG3_SYNC_BYTE;
  370. result = mpeg3io_read_data(demuxer->raw_data + 1, 
  371. file->packet_size - 1, 
  372. title->fs);
  373. }
  374. else
  375. return 1;
  377. packet_read_char(demuxer);
  378.     bits =  packet_read_int24(demuxer) & 0x00ffffff;
  379. //printf("read transport 3 tell=%x bits=%xn", mpeg3io_tell(title->fs), bits);
  380.     demuxer->transport_error_indicator = (bits >> 23) & 0x1;
  381.     demuxer->payload_unit_start_indicator = (bits >> 22) & 0x1;
  382.     demuxer->pid = (bits >> 8) & 0x00001fff;
  383.     demuxer->transport_scrambling_control = (bits >> 6) & 0x3;
  384.     demuxer->adaptation_field_control = (bits >> 4) & 0x3;
  385.     demuxer->continuity_counter = bits & 0xf;
  387. //printf("read_transport 4 %xn", demuxer->pid);
  388. if(demuxer->transport_error_indicator)
  389. {
  390. fprintf(stderr, "demuxer->transport_error_indicatorn");
  391. return 1;
  392. }
  394. //printf("read_transport 5 %xn", demuxer->pid);
  395.     if (demuxer->pid == 0x1fff)
  396. {
  397. demuxer->is_padding = 1;  /* padding; just go to next */
  398. return 0;
  399.     }
  400. else
  401. {
  402. demuxer->is_padding = 0;
  403. }
  405. //printf("read_transport 6 %xn", demuxer->pid);
  406. /* Get pid */
  407. for(table_entry = 0, result = 0; 
  408. table_entry < demuxer->total_pids; 
  409. table_entry++)
  410. {
  411. if(demuxer->pid == demuxer->pid_table[table_entry])
  412. {
  413. result = 1;
  414. break;
  415. }
  416. }
  418. //printf("read_transport 7 %xn", demuxer->pid);
  422. /* Not in pid table */
  423. if(!result)
  424. {
  425. demuxer->pid_table[table_entry] = demuxer->pid;
  426. demuxer->continuity_counters[table_entry] = demuxer->continuity_counter;  /* init */
  427. demuxer->total_pids++;
  428. //printf("read_transport program id detected %xn", demuxer->pid);
  429. }
  430. result = 0;
  434. #if 0
  435. /* Check counters */
  436.     if(demuxer->pid != MPEG3_PROGRAM_ASSOCIATION_TABLE && 
  437. demuxer->pid != MPEG3_CONDITIONAL_ACCESS_TABLE &&
  438.         (demuxer->adaptation_field_control == 1 || demuxer->adaptation_field_control == 3))
  439. {
  440. if(demuxer->continuity_counters[table_entry] != demuxer->continuity_counter)
  441. {
  442. // fprintf(stderr, "demuxer->continuity_counters[table_entry] != demuxer->continuity_countern");
  443. /* Reset it */
  444. demuxer->continuity_counters[table_entry] = demuxer->continuity_counter;
  445. }
  446. if(++(demuxer->continuity_counters[table_entry]) > 15) demuxer->continuity_counters[table_entry] = 0;
  447. }
  448. #endif
  456. //printf("read_transport 8 %x %xn", demuxer->adaptation_field_control, demuxer->pid);
  457.     if(demuxer->adaptation_field_control == 2 || 
  458. demuxer->adaptation_field_control == 3)
  459.      result = get_adaptation_field(demuxer);
  461. // Need to enter in astream and vstream table:
  462. // PID ored with stream_id
  463.     if(demuxer->adaptation_field_control == 1 || 
  464. demuxer->adaptation_field_control == 3)
  465.      result = get_payload(demuxer);
  467. return result;
  468. }
  470. static int get_system_header(mpeg3_demuxer_t *demuxer)
  471. {
  472. mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
  473. int length = mpeg3io_read_int16(title->fs);
  474. mpeg3io_seek_relative(title->fs, length);
  475. return 0;
  476. }
  478. static unsigned long get_timestamp(mpeg3_demuxer_t *demuxer)
  479. {
  480. unsigned long timestamp;
  481. mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
  483. /* Only low 4 bits (7==1111) */
  484. timestamp = (mpeg3io_read_char(title->fs) >> 1) & 7;  
  485. timestamp <<= 15;
  486. timestamp |= (mpeg3io_read_int16(title->fs) >> 1);
  487. timestamp <<= 15;
  488. timestamp |= (mpeg3io_read_int16(title->fs) >> 1);
  489. return timestamp;
  490. }
  492. static int get_pack_header(mpeg3_demuxer_t *demuxer)
  493. {
  494. unsigned long i, j;
  495. unsigned long clock_ref, clock_ref_ext;
  496. mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
  498. /* Get the time code */
  499. if((mpeg3io_next_char(title->fs) >> 4) == 2)
  500. {
  501. /* MPEG-1 */
  502. demuxer->time = (double)get_timestamp(demuxer) / 90000;
  503. /* Skip 3 bytes */
  504. mpeg3io_read_int24(title->fs);
  505. }
  506. else
  507. if(mpeg3io_next_char(title->fs) & 0x40)
  508. {
  509. i = mpeg3io_read_int32(title->fs);
  510. j = mpeg3io_read_int16(title->fs);
  512. if(i & 0x40000000 || (i >> 28) == 2)
  513. {
  514.      clock_ref = ((i & 0x38000000) << 3);
  515.      clock_ref |= ((i & 0x03fff800) << 4);
  516.      clock_ref |= ((i & 0x000003ff) << 5);
  517.      clock_ref |= ((j & 0xf800) >> 11);
  518.      clock_ref_ext = (j >> 1) & 0x1ff;
  520.     demuxer->time = (double)(clock_ref + clock_ref_ext / 300) / 90000;
  521. /* Skip 3 bytes */
  522. mpeg3io_read_int24(title->fs);
  523. i = mpeg3io_read_char(title->fs) & 0x7;
  525. /* stuffing */
  526. mpeg3io_seek_relative(title->fs, i);  
  527. }
  528. }
  529. else
  530. {
  531. mpeg3io_seek_relative(title->fs, 2);
  532. }
  533. return 0;
  534. }
  536. /* Program packet reading core */
  537. static int get_ps_pes_packet(mpeg3_demuxer_t *demuxer, unsigned int header)
  538. {
  539. unsigned long pts = 0, dts = 0;
  540. int stream_id;
  541. int pes_packet_length;
  542. long pes_packet_start;
  543. long decryption_offset;
  544. int i;
  545. mpeg3_t *file = demuxer->file;
  546. mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
  547. int scrambling = 0;
  549. stream_id = header & 0xff;
  550. pes_packet_length = mpeg3io_read_int16(title->fs);
  551. pes_packet_start = mpeg3io_tell(title->fs);
  560. if(stream_id != MPEG3_PRIVATE_STREAM_2 &&
  561. stream_id != MPEG3_PADDING_STREAM)
  562. {
  563. if((mpeg3io_next_char(title->fs) >> 6) == 0x02)
  564. {
  565. /* Get MPEG-2 packet */
  566. int pes_header_bytes = 0;
  567.      int pts_dts_flags;
  568. int pes_header_data_length;
  571. demuxer->last_packet_decryption = mpeg3io_tell(title->fs);
  572. scrambling = mpeg3io_read_char(title->fs) & 0x30;
  573. //scrambling = 1;
  574. /* Reset scrambling bit for the mpeg3cat utility */
  575. // if(scrambling) demuxer->raw_data[demuxer->raw_offset - 1] &= 0xcf;
  579.      pts_dts_flags = (mpeg3io_read_char(title->fs) >> 6) & 0x3;
  580. pes_header_data_length = mpeg3io_read_char(title->fs);
  584. /* Get Presentation and Decoding Time Stamps */
  585. if(pts_dts_flags == 2)
  586. {
  587. pts = (mpeg3io_read_char(title->fs) >> 1) & 7;  /* Only low 4 bits (7==1111) */
  588. pts <<= 15;
  589. pts |= (mpeg3io_read_int16(title->fs) >> 1);
  590. pts <<= 15;
  591. pts |= (mpeg3io_read_int16(title->fs) >> 1);
  592. pes_header_bytes += 5;
  593. }
  594.      else 
  595. if(pts_dts_flags == 3)
  596. {
  597.          pts = (mpeg3io_read_char(title->fs) >> 1) & 7;  /* Only low 4 bits (7==1111) */
  598.          pts <<= 15;
  599.          pts |= (mpeg3io_read_int16(title->fs) >> 1);
  600.          pts <<= 15;
  601.          pts |= (mpeg3io_read_int16(title->fs) >> 1);
  602.          dts = (mpeg3io_read_char(title->fs) >> 1) & 7;  /* Only low 4 bits (7==1111) */
  603.          dts <<= 15;
  604.          dts |= (mpeg3io_read_int16(title->fs) >> 1);
  605.          dts <<= 15;
  606.          dts |= (mpeg3io_read_int16(title->fs) >> 1);
  607.          pes_header_bytes += 10;
  608.      }
  610. /* Skip unknown */
  611.          mpeg3io_seek_relative(title->fs, 
  612. pes_header_data_length - pes_header_bytes);
  613. }
  614. else
  615. {
  616. int pts_dts_flags;
  617. /* Get MPEG-1 packet */
  618. while(mpeg3io_next_char(title->fs) == 0xff)
  619. {
  620. mpeg3io_read_char(title->fs);
  621. }
  623. /* Skip STD buffer scale */
  624. if((mpeg3io_next_char(title->fs) & 0x40) == 0x40)
  625. {
  626. mpeg3io_seek_relative(title->fs, 2);
  627. }
  629. /* Decide which timestamps are available */
  630. pts_dts_flags = mpeg3io_next_char(title->fs);
  632. if(pts_dts_flags >= 0x30)
  633. {
  634. /* Get the presentation and decoding time stamp */
  635. pts = get_timestamp(demuxer);
  636. dts = get_timestamp(demuxer);
  637. }
  638. else
  639. if(pts_dts_flags >= 0x20)
  640. {
  641. /* Get just the presentation time stamp */
  642. pts = get_timestamp(demuxer);
  643. }
  644. else
  645. if(pts_dts_flags == 0x0f)
  646. {
  647. /* End of timestamps */
  648. mpeg3io_read_char(title->fs);
  649. }
  650. else
  651. {
  652. return 1;     /* Error */
  653. }
  654. }
  656. /* Now extract the payload. */
  657. if((stream_id >> 4) == 0xc || (stream_id >> 4) == 0xd)
  658. {
  659. /* Audio data */
  660. /* Take first stream ID if -1 */
  661. pes_packet_length -= mpeg3io_tell(title->fs) - pes_packet_start;
  666. if(demuxer->read_all)
  667. demuxer->astream_table[stream_id & 0x0f] = AUDIO_MPEG;
  668. else
  669. if(demuxer->astream == -1) 
  670. demuxer->astream = stream_id & 0x0f;
  675. demuxer->pes_audio_time = demuxer->time;
  676. if(pts) demuxer->pes_audio_time = pts;
  679. if((stream_id & 0x0f) == demuxer->astream && demuxer->do_audio)
  680. {
  681. decryption_offset = mpeg3io_tell(title->fs) - demuxer->last_packet_start;
  682. mpeg3io_read_data(demuxer->data_buffer + demuxer->data_size, 
  683. pes_packet_length, 
  684. title->fs);
  685. demuxer->data_size += pes_packet_length;
  686.    }
  687. else 
  688. {
  689.      mpeg3io_seek_relative(title->fs, pes_packet_length);
  690. }
  691. }
  692.      else 
  693. if((stream_id >> 4) == 0xe)
  694. {
  695. /* Video data */
  696. /* Take first stream ID if -1 */
  697. pes_packet_length -= mpeg3io_tell(title->fs) - pes_packet_start;
  701. if(demuxer->read_all) 
  702. demuxer->vstream_table[stream_id & 0x0f] = 1;
  703. else
  704. if(demuxer->vstream == -1) 
  705. demuxer->vstream = stream_id & 0x0f;
  707.         demuxer->pes_video_time  = demuxer->time;;
  708.         if(pts) demuxer->pes_video_time = pts;
  712.          if((stream_id & 0x0f) == demuxer->vstream && demuxer->do_video)
  713. {
  714. //printf(__FUNCTION__ " stream_id=%x size=%xn", stream_id, pes_packet_length);
  715. decryption_offset = mpeg3io_tell(title->fs) - demuxer->last_packet_start;
  716. mpeg3io_read_data(demuxer->data_buffer + demuxer->data_size, 
  717. pes_packet_length, 
  718. title->fs);
  720. demuxer->data_size += pes_packet_length;
  721.         }
  722.      else 
  723. {
  724.      mpeg3io_seek_relative(title->fs, pes_packet_length);
  725.      }
  726.      }
  727.      else 
  728. if((stream_id == 0xbd || stream_id == 0xbf) && 
  729. mpeg3io_next_char(title->fs) != 0xff &&
  730. ((mpeg3io_next_char(title->fs) & 0xf0) != 0x20))
  731. {
  732. /* DVD audio data */
  733. /* Get the audio format */
  734. int format;
  735. //printf("get_ps_pes_packet 5 %xn", packet_next_char(demuxer) & 0xf0);
  736. if((mpeg3io_next_char(title->fs) & 0xf0) == 0xa0)
  737. format = AUDIO_PCM;
  738. else
  739. format = AUDIO_AC3;
  741. // Picks up bogus data if (& 0xf) or (& 0x7f)
  742. stream_id = mpeg3io_next_char(title->fs);
  743. demuxer->pes_audio_time = demuxer->time;
  744.         if(pts) demuxer->pes_audio_time = pts;
  746. //printf("get_ps_pes_packet %xn", stream_id);
  747. /* Take first stream ID if not building TOC. */
  748. if(demuxer->read_all)
  749. demuxer->astream_table[stream_id] = format;
  750. else
  751. if(demuxer->astream == -1)
  752. demuxer->astream = stream_id;
  754.        if(stream_id == demuxer->astream && demuxer->do_audio)
  755. {
  756. demuxer->aformat = format;
  757. mpeg3io_read_int32(title->fs);
  759. pes_packet_length -= mpeg3io_tell(title->fs) - pes_packet_start;
  760. decryption_offset = mpeg3io_tell(title->fs) - demuxer->last_packet_start;
  761. mpeg3io_read_data(demuxer->data_buffer + demuxer->data_size, 
  762. pes_packet_length, 
  763. title->fs);
  764. demuxer->data_size += pes_packet_length;
  765.        }
  766.        else
  767. {
  768. pes_packet_length -= mpeg3io_tell(title->fs) - pes_packet_start;
  769.      mpeg3io_seek_relative(title->fs, pes_packet_length);
  770.        }
  771. //printf("get_ps_pes_packet 6 %dn", demuxer->astream_table[0x20]);
  772.      }
  773.      else 
  774. if(stream_id == 0xbc || 1)
  775. {
  776. pes_packet_length -= mpeg3io_tell(title->fs) - pes_packet_start;
  777.      mpeg3io_seek_relative(title->fs, pes_packet_length);
  778.      }
  779. }
  780.    else 
  781. if(stream_id == MPEG3_PRIVATE_STREAM_2 || stream_id == MPEG3_PADDING_STREAM)
  782. {
  783. pes_packet_length -= mpeg3io_tell(title->fs) - pes_packet_start;
  784.      mpeg3io_seek_relative(title->fs, pes_packet_length);
  785.    }
  791. // Advance 2048 bytes if scrambled.  We might pick up a spurrius
  792. // packet start code in the scrambled data otherwise.
  793. if(scrambling && 
  794. demuxer->last_packet_start + 0x800 > mpeg3io_tell(title->fs))
  795. {
  796. mpeg3io_seek_relative(title->fs, 
  797. demuxer->last_packet_start + 0x800 - mpeg3io_tell(title->fs));
  798. }
  804. // Descramble if desired
  805. if(demuxer->data_size && scrambling)
  806. {
  807. //printf(__FUNCTION__ " data_size=%x decryption_offset=%xn", demuxer->data_size, decryption_offset);
  808. if(mpeg3_decrypt_packet(title->fs->css, 
  809. demuxer->data_buffer,
  810. decryption_offset))
  811. {
  812. fprintf(stderr, "get_ps_pes_packet: Decryption not availablen");
  813. return 1;
  814. }
  815. }
  817. //if(mpeg3io_tell(title->fs) - demuxer->last_packet_start != 0x800)
  818. // printf(__FUNCTION__ " packet size == %dn", mpeg3io_tell(title->fs) - demuxer->last_packet_start);
  820. return 0;
  821. }
  823. int mpeg3demux_read_program(mpeg3_demuxer_t *demuxer)
  824. {
  825. int result = 0;
  826. int count = 0;
  827. mpeg3_t *file = demuxer->file;
  828. mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
  829. unsigned int header = 0;
  830. int pack_count = 0;
  832. demuxer->data_size = 0;
  833. //printf("mpeg3demux_read_program 1 %d %x %llxn", result, title->fs->current_byte, title->fs->total_bytes);
  835. if(mpeg3io_eof(title->fs)) return 1;
  837. //printf("mpeg3demux_read_program 2 %d %x %llxn", result, title->fs->current_byte, title->fs->total_bytes);
  845. /* Search for next header */
  846. /* Parse packet until the next packet start code */
  847. while(!result && !mpeg3io_eof(title->fs))
  848. {
  849. header = mpeg3io_read_int32(title->fs);
  853. if(header == MPEG3_PACK_START_CODE)
  854. {
  857. // Start of next packet
  858. if(pack_count)
  859. {
  860. mpeg3io_seek_relative(title->fs, -4);
  861. break;
  862. }
  864. demuxer->last_packet_start = mpeg3io_tell(title->fs) - 4;
  865. result = get_pack_header(demuxer);
  866. //printf("mpeg3demux_read_program MPEG3_PACK_START_CODE %dn", result);
  867. pack_count++;
  871. }
  872. else
  873. if(header == MPEG3_SYSTEM_START_CODE && pack_count)
  874. {
  878.   result = get_system_header(demuxer);
  879. //printf("mpeg3demux_read_program MPEG3_SYSTEM_START_CODE %dn", result);
  883. }
  884. else
  885. if((header >> 8) == MPEG3_PACKET_START_CODE_PREFIX && pack_count)
  886. {
  889. result = get_ps_pes_packet(demuxer, header);
  890. //printf("mpeg3demux_read_program MPEG3_PACKET_START_CODE_PREFIX %d %08xn", result, header);
  894. }
  895. else
  896. {
  897. // Try again.
  898. mpeg3io_seek_relative(title->fs, -3);
  899. }
  900. }
  901. //printf("mpeg3demux_read_program 3 %d %x %llxn", result, title->fs->current_byte, title->fs->total_bytes);
  909. // Ignore errors in the parsing.  Just quit if eof.
  910. result = 0;
  917. demuxer->last_packet_end = mpeg3io_tell(title->fs);
  919. /*
  920.  * if(demuxer->last_packet_end - demuxer->last_packet_start != 0x800)
  921.  *  printf(__FUNCTION__ " packet_size=%x data_size=%x packet_start=%xn",
  922.  *  demuxer->last_packet_end - demuxer->last_packet_start,
  923.  *  demuxer->data_size,
  924.  *  demuxer->last_packet_start);
  925.  */
  926. //printf("mpeg3demux_read_program 5 %dn", result);
  928. //printf("read_program 3n");
  929. // if(!result) result = mpeg3io_eof(title->fs);
  931. return result;
  932. }
  934. static double lookup_time_offset(mpeg3_demuxer_t *demuxer, long byte)
  935. {
  936. int i;
  937. mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
  939. if(!title->timecode_table_size) return 0;
  941. for(i = title->timecode_table_size - 1; 
  942. i >= 0 && title->timecode_table[i].start_byte > byte;
  943. i--)
  944. ;
  945. if(i < 0) i = 0;
  946. return title->timecode_table[i].absolute_start_time - title->timecode_table[i].start_time;
  947. }
  985. int mpeg3_advance_timecode(mpeg3_demuxer_t *demuxer)
  986. {
  987. mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
  988. int result = 0;
  989. int do_seek = 0;
  990. int last_timecode = demuxer->current_timecode;
  991. //printf("mpeg3_advance_timecode 0n");fflush(stdout);
  998. /* Don't do anything when constructing timecode table */
  999. if(!title->timecode_table || 
  1000. !title->timecode_table_size || 
  1001. demuxer->read_all) return 0;
  1007. //printf("mpeg3_advance_timecode 1n");fflush(stdout);
  1008. if(!demuxer->reverse)
  1009. {
  1014. /* Get inside the current timecode */
  1015. if(mpeg3io_tell(title->fs) < title->timecode_table[demuxer->current_timecode].start_byte)
  1016. {
  1017. mpeg3io_seek(title->fs, 
  1018. title->timecode_table[demuxer->current_timecode].start_byte);
  1019. }
  1025. /* Get the next timecode */
  1026. while(!result && 
  1027. (mpeg3io_tell(title->fs) >= title->timecode_table[demuxer->current_timecode].end_byte ||
  1028. demuxer->current_program != title->timecode_table[demuxer->current_timecode].program))
  1029. {
  1030. demuxer->current_timecode++;
  1032. if(demuxer->current_timecode >= title->timecode_table_size)
  1033. {
  1034. demuxer->current_timecode = 0;
  1035. if(demuxer->current_title + 1 < demuxer->total_titles)
  1036. {
  1037. mpeg3demux_open_title(demuxer, ++demuxer->current_title);
  1038. do_seek = 1;
  1039. }
  1040. else
  1041. {
  1042. mpeg3io_seek(title->fs, mpeg3io_total_bytes(title->fs));
  1043.   result = 1;
  1044. }
  1045. }
  1048. title = demuxer->titles[demuxer->current_title];
  1049. }
  1055. //if(last_timecode != demuxer->current_timecode && demuxer->do_video)
  1056. // printf("using title %d cell %x-%xn", demuxer->current_title, title->timecode_table[demuxer->current_timecode].start_byte, title->timecode_table[demuxer->current_timecode].end_byte);
  1058. //printf("2 %dn", title->timecode_table[demuxer->current_timecode].program);
  1064. if(!result && do_seek)
  1065. {
  1066. //printf("current_cell=%dn", demuxer->current_timecode);
  1067. mpeg3io_seek(title->fs, 
  1068. title->timecode_table[demuxer->current_timecode].start_byte);
  1069. }
  1070. }
  1071. else
  1072. {
  1083. /* Get the previous timecode */
  1084. while(!result && 
  1085. (mpeg3io_tell(title->fs) < title->timecode_table[demuxer->current_timecode].start_byte ||
  1086. demuxer->current_program != title->timecode_table[demuxer->current_timecode].program))
  1087. {
  1088. /*
  1089.  * printf("mpeg3_reverse_timecode %d %d %d %dn", 
  1090.  *  mpeg3io_tell(title->fs), 
  1091.  *  demuxer->current_timecode,
  1092.  *  title->timecode_table[demuxer->current_timecode].start_byte,
  1093.  *  title->timecode_table[demuxer->current_timecode].end_byte);
  1094.  */
  1096. demuxer->current_timecode--;
  1097. if(demuxer->current_timecode < 0)
  1098. {
  1099. if(demuxer->current_title > 0)
  1100. {
  1101. //printf("advance_timecode 2 %dn", demuxer->current_title);
  1102. mpeg3demux_open_title(demuxer, --demuxer->current_title);
  1103. title = demuxer->titles[demuxer->current_title];
  1104. // Seek to end since we opened at the beginning of the next title
  1105. mpeg3io_seek(title->fs, title->total_bytes);
  1106. //printf("advance_timecode 3 %d %dn", demuxer->current_title, mpeg3io_tell(title->fs));
  1107. demuxer->current_timecode = title->timecode_table_size - 1;
  1108. do_seek = 1;
  1109. }
  1110. else
  1111. {
  1112. mpeg3io_seek(title->fs, 0);
  1113. demuxer->current_timecode = 0;
  1114. result = 1;
  1115. }
  1116. }
  1117. }
  1125. if(!result && do_seek)
  1126. {
  1127. mpeg3io_seek(title->fs, 
  1128. title->timecode_table[demuxer->current_timecode].start_byte);
  1129. }
  1134. }
  1136. //printf("mpeg3_advance_timecode 2 %dn", demuxer->current_title);fflush(stdout);
  1137. return result;
  1138. }
  1153. /* Read packet in the forward direction */
  1154. int mpeg3_read_next_packet(mpeg3_demuxer_t *demuxer)
  1155. {
  1156. int result = 0;
  1157. long current_position;
  1158. mpeg3_t *file = demuxer->file;
  1159. mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
  1160. demuxer->data_size = 0;
  1161. demuxer->data_position = 0;
  1163. //printf("mpeg3_read_next_packet 1 %d %llxn", demuxer->current_title, mpeg3io_tell(title->fs));
  1164. /* Switch to forward direction. */
  1165. if(demuxer->reverse)
  1166. {
  1167. if(file->packet_size > 0)
  1168. {
  1169. if(!result) result = mpeg3io_seek_relative(title->fs, file->packet_size);
  1170. }
  1171. else
  1172. {
  1173. if(!result) result = mpeg3io_next_code(title->fs, MPEG3_PACK_START_CODE, MPEG3_RAW_SIZE);
  1174. if(!result) result = mpeg3io_next_code(title->fs, MPEG3_PACK_START_CODE, MPEG3_RAW_SIZE);
  1175. }
  1177. demuxer->reverse = 0;
  1178. }
  1179. //printf("mpeg3_read_next_packet 4 %dn", result);
  1188. /* Read packets until the output buffer is full */
  1189. if(!result)
  1190. {
  1191. do
  1192. {
  1193. result = mpeg3_advance_timecode(demuxer);
  1195. if(!result)
  1196. {
  1197. demuxer->time_offset = lookup_time_offset(demuxer, mpeg3io_tell(title->fs));
  1199. if(file->is_transport_stream)
  1200. {
  1201. //printf("mpeg3_read_next_packet: 1 %fn", demuxer->time);
  1202. result = read_transport(demuxer);
  1203. //printf("mpeg3_read_next_packet: 2 %fn", demuxer->time);
  1204. }
  1205. else
  1206. if(file->is_program_stream)
  1207. {
  1208. result = mpeg3demux_read_program(demuxer);
  1209. }
  1210. else
  1211. {
  1212. /* Read elementary stream. */
  1213. //printf("mpeg3_read_next_packet: 3n");
  1214. result = mpeg3io_read_data(demuxer->data_buffer, 
  1215. file->packet_size, title->fs);
  1216. if(!result) demuxer->data_size = file->packet_size;
  1217. }
  1218. }
  1219. //printf("mpeg3_read_next_packet 2 %x %lxn", demuxer->data_size, mpeg3io_tell(title->fs));
  1220. }while(!result && 
  1221. demuxer->data_size == 0 && 
  1222. (demuxer->do_audio || demuxer->do_video));
  1223. }
  1225. //printf("mpeg3_read_next_packet 4 %dn", result);
  1226. return result;
  1227. }
  1244. /* Read the packet right before the packet we're currently on. */
  1245. int mpeg3_read_prev_packet(mpeg3_demuxer_t *demuxer)
  1246. {
  1247. int result = 0;
  1248. mpeg3_t *file = demuxer->file;
  1249. long current_position;
  1250. mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
  1251. demuxer->data_size = 0;
  1252. demuxer->data_position = 0;
  1260. //printf("mpeg3_read_prev_packet 1 %x %xn", title->fs->current_byte, title->fs->buffer_position);
  1261. /* Switch to reverse direction */
  1262. if(!demuxer->reverse)
  1263. {
  1264. if(file->packet_size > 0)
  1265. {
  1266. result = mpeg3io_seek_relative(title->fs, -file->packet_size);
  1267. }
  1268. else
  1269. {
  1270. result = mpeg3io_prev_code(title->fs, MPEG3_PACK_START_CODE, MPEG3_RAW_SIZE);
  1271. }
  1273. demuxer->reverse = 1;
  1274. }
  1280. //printf("mpeg3_read_prev_packet 2 %x %xn", title->fs->current_byte, title->fs->buffer_position);
  1283. do
  1284. {
  1285. // Go to beginning of previous packet
  1287. if(file->packet_size > 0)
  1288. {
  1289. if(!result) result = mpeg3io_seek_relative(title->fs, -file->packet_size);
  1290. }
  1291. else
  1292. {
  1293. if(!result) result = mpeg3io_prev_code(title->fs, MPEG3_PACK_START_CODE, MPEG3_RAW_SIZE);
  1294. }
  1296. //printf("mpeg3_read_prev_packet 3 %x %xn", title->fs->current_byte, title->fs->buffer_position);
  1297. if(!result) result = mpeg3_advance_timecode(demuxer);
  1299. //printf("mpeg3_read_prev_packet 2 %p->%p->%pn", title, title->fs, title->fs->fd);
  1300. if(!result) demuxer->time_offset = lookup_time_offset(demuxer, mpeg3io_tell(title->fs));
  1302. // Read packet and then rewind it
  1303. if(file->is_transport_stream && !result)
  1304. {
  1305. result = read_transport(demuxer);
  1307. if(!mpeg3io_bof(title->fs))
  1308. {
  1309. result = mpeg3io_seek_relative(title->fs, -file->packet_size);
  1310. }
  1311. //printf("mpeg3_read_prev_packet 4 %x %xn", title->fs->current_byte, title->fs->buffer_position);
  1312. }
  1313. else
  1314. if(file->is_program_stream && !result)
  1315. {
  1316. result = mpeg3demux_read_program(demuxer);
  1317. //printf("mpeg3_read_prev_packet 4 %x %xn", title->fs->current_byte);
  1318. if(!mpeg3io_bof(title->fs))
  1319. result = mpeg3io_prev_code(title->fs, MPEG3_PACK_START_CODE, MPEG3_RAW_SIZE);
  1320. //printf("mpeg3_read_prev_packet 5 %x %xn", title->fs->current_byte);
  1321. }
  1322. else
  1323. if(!result)
  1324. {
  1325. /* Elementary stream */
  1326. /* Read the packet forwards and seek back to the start */
  1327. result = mpeg3io_read_data(demuxer->data_buffer, 
  1328. file->packet_size, 
  1329. title->fs);
  1331. if(!result) 
  1332. {
  1333. demuxer->data_size = file->packet_size;
  1334. result = mpeg3io_seek_relative(title->fs, -file->packet_size);
  1335. }
  1336. }
  1337. }while(!result && 
  1338. demuxer->data_size == 0 && 
  1339. (demuxer->do_audio || demuxer->do_video));
  1342. //printf("mpeg3_read_prev_packet 4 %x %xn", title->fs->current_byte, title->fs->buffer_position);
  1343. return result;
  1344. }
  1347. /* For audio */
  1348. int mpeg3demux_read_data(mpeg3_demuxer_t *demuxer, 
  1349. unsigned char *output, 
  1350. long size)
  1351. {
  1352. long i;
  1353. int result = 0;
  1354. mpeg3_t *file = demuxer->file;
  1355. demuxer->error_flag = 0;
  1357. if(demuxer->data_position >= 0)
  1358. {
  1359. /* Read forwards */
  1360. for(i = 0; i < size && !result; )
  1361. {
  1362. int fragment_size = size - i;
  1363. if(fragment_size > demuxer->data_size - demuxer->data_position)
  1364. fragment_size = demuxer->data_size - demuxer->data_position;
  1365. memcpy(output + i, demuxer->data_buffer + demuxer->data_position, fragment_size);
  1366. demuxer->data_position += fragment_size;
  1367. i += fragment_size;
  1369. if(i < size)
  1370. {
  1371. result = mpeg3_read_next_packet(demuxer);
  1372. }
  1373. }
  1374. return i;
  1375. }
  1376. else
  1377. {
  1378. /* Read backwards a full packet. */
  1379. /* Only good for reading less than the size of a full packet, but */
  1380. /* this routine should only be used for searching for previous markers. */
  1381. long current_position = demuxer->data_position;
  1382. result = mpeg3_read_prev_packet(demuxer);
  1383. if(!result) demuxer->data_position = demuxer->data_size + current_position;
  1384. memcpy(output, demuxer->data_buffer + demuxer->data_position, size);
  1385. demuxer->data_position += size;
  1386. }
  1388. demuxer->error_flag = result;
  1389. return result;
  1390. }
  1392. unsigned char mpeg3demux_read_char_packet(mpeg3_demuxer_t *demuxer)
  1393. {
  1394. demuxer->error_flag = 0;
  1396. if(demuxer->data_position >= demuxer->data_size)
  1397. demuxer->error_flag = mpeg3_read_next_packet(demuxer);
  1398. demuxer->next_char = demuxer->data_buffer[demuxer->data_position++];
  1400. return demuxer->next_char;
  1401. }
  1403. unsigned char mpeg3demux_read_prev_char_packet(mpeg3_demuxer_t *demuxer)
  1404. {
  1405. demuxer->error_flag = 0;
  1406. demuxer->data_position--;
  1407. if(demuxer->data_position < 0)
  1408. {
  1409. //printf("mpeg3demux_read_prev_char_packet 1n");
  1410. demuxer->error_flag = mpeg3_read_prev_packet(demuxer);
  1411. //printf("mpeg3demux_read_prev_char_packet 2n");
  1412. if(!demuxer->error_flag) demuxer->data_position = demuxer->data_size - 1;
  1413. }
  1414. demuxer->next_char = demuxer->data_buffer[demuxer->data_position];
  1415. return demuxer->next_char;
  1416. }
  1418. static mpeg3demux_timecode_t* next_timecode(mpeg3_demuxer_t *demuxer, 
  1419. int *current_title, 
  1420. int *current_timecode,
  1421. int current_program)
  1422. {
  1423. int done = 0;
  1424. while(!done)
  1425. {
  1426. /* Increase timecode number */
  1427. if(*current_timecode < demuxer->titles[*current_title]->timecode_table_size - 1) 
  1428. {
  1429. (*current_timecode)++;
  1430. if(demuxer->titles[*current_title]->timecode_table[*current_timecode].program == current_program)
  1431. return &(demuxer->titles[*current_title]->timecode_table[*current_timecode]);
  1432. }
  1433. else
  1434. /* Increase title number */
  1435. if(*current_title < demuxer->total_titles - 1)
  1436. {
  1437. (*current_title)++;
  1438. (*current_timecode) = 0;
  1439. if(demuxer->titles[*current_title]->timecode_table[*current_timecode].program == current_program)
  1440. return &(demuxer->titles[*current_title]->timecode_table[*current_timecode]);
  1441. }
  1442. else
  1443. /* End of disk */
  1444. done = 1;
  1445. }
  1446. return 0;
  1447. }
  1449. static mpeg3demux_timecode_t* prev_timecode(mpeg3_demuxer_t *demuxer, 
  1450. int *current_title, 
  1451. int *current_timecode,
  1452. int current_program)
  1453. {
  1454. int done = 0;
  1455. while(!done)
  1456. {
  1457. /* Increase timecode number */
  1458. if(*current_timecode > 0)
  1459. {
  1460. (*current_timecode)--;
  1461. if(demuxer->titles[*current_title]->timecode_table[*current_timecode].program == current_program)
  1462. return &(demuxer->titles[*current_title]->timecode_table[*current_timecode]);
  1463. }
  1464. else
  1465. /* Increase title number */
  1466. if(*current_title > 0)
  1467. {
  1468. (*current_title)--;
  1469. (*current_timecode) = demuxer->titles[*current_title]->timecode_table_size - 1;
  1470. if(demuxer->titles[*current_title]->timecode_table[*current_timecode].program == current_program)
  1471. return &(demuxer->titles[*current_title]->timecode_table[*current_timecode]);
  1472. }
  1473. else
  1474. /* End of disk */
  1475. done = 1;
  1477. }
  1478. return 0;
  1479. }
  1481. int mpeg3demux_open_title(mpeg3_demuxer_t *demuxer, int title_number)
  1482. {
  1483. mpeg3_title_t *title;
  1485. //printf("mpeg3demux_open_title 1n");
  1486. if(title_number < demuxer->total_titles)
  1487. {
  1488. if(demuxer->current_title >= 0)
  1489. {
  1490. mpeg3io_close_file(demuxer->titles[demuxer->current_title]->fs);
  1491. demuxer->current_title = -1;
  1492. }
  1494. //printf("mpeg3demux_open_title %p %p %dn", demuxer, demuxer->titles, title_number);
  1495. title = demuxer->titles[title_number];
  1497. if(mpeg3io_open_file(title->fs))
  1498. {
  1499. demuxer->error_flag = 1;
  1500. fprintf(stderr, "mpeg3demux_open_title %s: %s", title->fs->path, strerror(errno));
  1501. }
  1502. else
  1503. {
  1504. demuxer->current_title = title_number;
  1505. }
  1506. }
  1508. //printf("mpeg3demux_open_title 2n");
  1509. // demuxer->current_timecode = 0;
  1511. return demuxer->error_flag;
  1512. }
  1514. /* Assign program numbers to interleaved programs */
  1515. int mpeg3demux_assign_programs(mpeg3_demuxer_t *demuxer)
  1516. {
  1517. int current_program = 0;
  1518. int current_title = 0;
  1519. int current_timecode = 0;
  1520. double current_time;
  1521. mpeg3demux_timecode_t *timecode;
  1522. int total_programs = 1;
  1523. int i, j;
  1524. int program_exists, last_program_assigned = 0;
  1525. int total_timecodes;
  1526. mpeg3_title_t **titles = demuxer->titles;
  1528. for(i = 0, total_timecodes = 0; i < demuxer->total_titles; i++)
  1529. {
  1530. total_timecodes += demuxer->titles[i]->timecode_table_size;
  1531. for(j = 0; j < demuxer->titles[i]->timecode_table_size; j++)
  1532. {
  1533. timecode = &demuxer->titles[i]->timecode_table[j];
  1534. if(timecode->program > total_programs - 1)
  1535. total_programs = timecode->program + 1;
  1536. }
  1537. }
  1539. /* Assign absolute timecodes in each program. */
  1540. for(current_program = 0; 
  1541. current_program < total_programs; 
  1542. current_program++)
  1543. {
  1544. current_time = 0;
  1545. current_title = 0;
  1546. current_timecode = -1;
  1547. while(timecode = next_timecode(demuxer, 
  1548.     &current_title, 
  1549. &current_timecode, 
  1550. current_program))
  1551. {
  1552. timecode->absolute_start_time = current_time;
  1554. /*
  1555.  * printf("mpeg3demux_assign_programs %p end: %f start: %fn", 
  1556.  *  timecode,
  1557.  *  timecode->end_time,
  1558.  *  timecode->start_time);
  1559.  */
  1561. current_time += fabs(timecode->end_time - timecode->start_time);
  1562. timecode->absolute_end_time = current_time;
  1563. }
  1564. }
  1566. //for(i = 0; i < demuxer->total_titles; i++) mpeg3_dump_title(demuxer->titles[i]);
  1568. demuxer->current_program = 0;
  1569. return 0;
  1570. }
  1572. int mpeg3demux_copy_titles(mpeg3_demuxer_t *dst, mpeg3_demuxer_t *src)
  1573. {
  1574. long i;
  1575. mpeg3_t *file = dst->file;
  1576. mpeg3_title_t *dst_title, *src_title;
  1578. dst->total_titles = src->total_titles;
  1579. dst->total_programs = src->total_programs;
  1580. for(i = 0; i < MPEG3_MAX_STREAMS; i++)
  1581. {
  1582. dst->astream_table[i] = src->astream_table[i];
  1583. dst->vstream_table[i] = src->vstream_table[i];
  1584. }
  1585. for(i = 0; i < src->total_titles; i++)
  1586. {
  1587. src_title = src->titles[i];
  1588. dst_title = dst->titles[i] = mpeg3_new_title(file, src->titles[i]->fs->path);
  1589. mpeg3_copy_title(dst_title, src_title);
  1590. }
  1592. mpeg3demux_open_title(dst, src->current_title);
  1593. dst->current_timecode = 0;
  1594. return 0;
  1595. }
  1597. /* ==================================================================== */
  1598. /*                            Entry points */
  1599. /* ==================================================================== */
  1601. mpeg3_demuxer_t* mpeg3_new_demuxer(mpeg3_t *file, int do_audio, int do_video, int stream_id)
  1602. {
  1603. mpeg3_demuxer_t *demuxer = calloc(1, sizeof(mpeg3_demuxer_t));
  1604. int i;
  1606. /* The demuxer will change the default packet size for its own use. */
  1607. demuxer->file = file;
  1608. demuxer->do_audio = do_audio;
  1609. demuxer->do_video = do_video;
  1611. /* Allocate buffer + padding */
  1612. demuxer->raw_data = calloc(1, MPEG3_RAW_SIZE);
  1613. demuxer->data_buffer = calloc(1, MPEG3_RAW_SIZE);
  1614. /* System specific variables */
  1615. demuxer->audio_pid = stream_id;
  1616. demuxer->video_pid = stream_id;
  1617. demuxer->astream = stream_id;
  1618. demuxer->vstream = stream_id;
  1619. demuxer->current_title = -1;
  1620. //printf("mpeg3_new_demuxer %fn", demuxer->time);
  1621. return demuxer;
  1622. }
  1624. int mpeg3_delete_demuxer(mpeg3_demuxer_t *demuxer)
  1625. {
  1626. int i;
  1628. if(demuxer->current_title >= 0)
  1629. {
  1630. mpeg3io_close_file(demuxer->titles[demuxer->current_title]->fs);
  1631. }
  1633. for(i = 0; i < demuxer->total_titles; i++)
  1634. {
  1635. mpeg3_delete_title(demuxer->titles[i]);
  1636. }
  1638. free(demuxer->data_buffer);
  1639. free(demuxer->raw_data);
  1640. free(demuxer);
  1641. return 0;
  1642. }
  1644. /* Need a timecode table to do this */
  1645. double mpeg3demux_length(mpeg3_demuxer_t *demuxer)
  1646. {
  1647. mpeg3_title_t *title;
  1648. int i, j;
  1649. double length;
  1651. for(i = demuxer->total_titles - 1; i >= 0; i--)
  1652. {
  1653. title = demuxer->titles[i];
  1654. for(j = title->timecode_table_size - 1; j >= 0; j--)
  1655. {
  1656. if(title->timecode_table[j].program == demuxer->current_program)
  1657. {
  1658. /*
  1659.  * printf("mpeg3demux_length %f %f %f %fn", 
  1660.  *  title->timecode_table[j].end_time, 
  1661.  *  title->timecode_table[j].start_time,
  1662.  *  title->timecode_table[j].absolute_start_time,
  1663.  *  title->timecode_table[j].end_time - title->timecode_table[j].start_time);
  1664.  */
  1665. return title->timecode_table[j].end_time - 
  1666. title->timecode_table[j].start_time + 
  1667. title->timecode_table[j].absolute_start_time;
  1668. }
  1669. }
  1670. }
  1672. return 1;
  1673. }
  1675. int mpeg3demux_eof(mpeg3_demuxer_t *demuxer)
  1676. {
  1677. if(demuxer->current_title >= 0)
  1678. {
  1679. if(mpeg3io_eof(demuxer->titles[demuxer->current_title]->fs) &&
  1680. demuxer->current_title >= demuxer->total_titles - 1)
  1681. return 1;
  1682. }
  1684. return 0;
  1685. }
  1687. int mpeg3demux_bof(mpeg3_demuxer_t *demuxer)
  1688. {
  1689. if(demuxer->current_title >= 0)
  1690. {
  1691. if(mpeg3io_bof(demuxer->titles[demuxer->current_title]->fs) &&
  1692. demuxer->current_title <= 0)
  1693. return 1;
  1694. }
  1695. return 0;
  1696. }
  1698. void mpeg3demux_start_reverse(mpeg3_demuxer_t *demuxer)
  1699. {
  1700. demuxer->reverse = 1;
  1701. }
  1703. void mpeg3demux_start_forward(mpeg3_demuxer_t *demuxer)
  1704. {
  1705. demuxer->reverse = 0;
  1706. }
  1708. /* Seek to a byte in the current title */
  1709. int mpeg3demux_seek_byte(mpeg3_demuxer_t *demuxer, int64_t byte)
  1710. {
  1711. long current_position;
  1712. mpeg3_t *file = demuxer->file;
  1713. mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
  1715. demuxer->data_position = 0;
  1716. demuxer->data_size = 0;
  1718. demuxer->error_flag = mpeg3io_seek(title->fs, byte);
  1720. if(!demuxer->error_flag && 
  1721. file->is_transport_stream &&
  1722. file->packet_size)
  1723. {
  1724. /* Get on a packet boundary only for transport streams. */
  1725. current_position = mpeg3io_tell(title->fs);
  1726. if(byte % file->packet_size)
  1727. {
  1728. demuxer->error_flag |= mpeg3io_seek(title->fs, 
  1729. current_position - 
  1730. (current_position % file->packet_size));
  1731. }
  1732. }
  1735. // Get current cell
  1736. for(demuxer->current_timecode = 0; 
  1737. demuxer->current_timecode < title->timecode_table_size; 
  1738. demuxer->current_timecode++)
  1739. {
  1740. if(title->timecode_table[demuxer->current_timecode].start_byte <= byte &&
  1741. title->timecode_table[demuxer->current_timecode].end_byte > byte)
  1742. {
  1743. break;
  1744. }
  1745. }
  1747. if(demuxer->current_timecode >= title->timecode_table_size)
  1748. demuxer->current_timecode = title->timecode_table_size - 1;
  1751. return demuxer->error_flag;
  1752. }
  1754. int mpeg3demux_seek_end(mpeg3_demuxer_t *demuxer)
  1755. {
  1756. mpeg3demux_open_title(demuxer, demuxer->total_titles - 1);
  1757. demuxer->current_timecode = 0;
  1758. return mpeg3demux_seek_byte(demuxer, demuxer->titles[demuxer->current_title]->total_bytes);
  1759. }
  1761. int mpeg3demux_seek_start(mpeg3_demuxer_t *demuxer)
  1762. {
  1763. mpeg3demux_open_title(demuxer, 0);
  1764. demuxer->current_timecode = 0;
  1765. return mpeg3demux_seek_byte(demuxer, 0);
  1766. }
  1768. /* For programs streams and toc seek to a time */
  1769. int mpeg3demux_seek_time(mpeg3_demuxer_t *demuxer, double new_time)
  1770. {
  1771. int i, j, done = 0, result = 0;
  1772. int64_t byte_offset, new_byte_offset;
  1773. double guess = 0, minimum = 65535;
  1774. mpeg3_title_t *title;
  1775. mpeg3demux_timecode_t *timecode;
  1777. demuxer->error_flag = 0;
  1779. i = 0;
  1780. j = 0;
  1781. title = demuxer->titles[i];
  1782. timecode = &title->timecode_table[j];
  1785. /* Get the title and timecode of the new position */
  1786. while(!demuxer->error_flag &&
  1787. !(timecode->absolute_start_time <= new_time &&
  1788. timecode->absolute_end_time > new_time &&
  1789. timecode->program == demuxer->current_program))
  1790. {
  1791. /* Next timecode */
  1792. j++;
  1793. if(j >= title->timecode_table_size)
  1794. {
  1795. i++;
  1796. j = 0;
  1797. if(i >= demuxer->total_titles)
  1798. {
  1799. demuxer->error_flag = 1;
  1800. return 1;
  1801. }
  1802. }
  1804. title = demuxer->titles[i];
  1805. timecode = &title->timecode_table[j];
  1806. }
  1808. //printf("mpeg3demux_seek_time 1 %d %f %f %fn", i, timecode->absolute_start_time, timecode->absolute_end_time, new_time);
  1809. if(demuxer->current_title != i)
  1810.      mpeg3demux_open_title(demuxer, i);
  1819. /* Guess the new byte position by interpolating */
  1820. demuxer->current_timecode = j;
  1822. byte_offset = ((new_time - timecode->absolute_start_time) /
  1823. (timecode->absolute_end_time - timecode->absolute_start_time) *
  1824. (timecode->end_byte - timecode->start_byte) +
  1825. timecode->start_byte);
  1826. //printf("mpeg3demux_seek_time %f %fn", new_time, byte_offset);
  1837. /* Binary search */
  1838. while(!done && !result && byte_offset >= 0)
  1839. {
  1840. result = mpeg3demux_seek_byte(demuxer, (long)byte_offset);
  1841. //printf("seek_time 0 byte %.0f want %f result %dn", byte_offset, new_time, result); 
  1843. if(!result)
  1844. {
  1845. result = mpeg3_read_next_packet(demuxer);
  1846. // printf("seek_time 1 guess %f want %fn", guess, new_time); 
  1847. guess = demuxer->time + demuxer->time_offset;
  1849. if(fabs(new_time - guess) >= fabs(minimum)) done = 1;
  1850. else
  1851. {
  1852. minimum = guess - new_time;
  1853. new_byte_offset = byte_offset + ((new_time - guess) / 
  1854. (timecode->end_time - timecode->start_time) *
  1855. (timecode->end_byte - timecode->start_byte));
  1856. if(fabs(new_byte_offset - byte_offset) < 1) done = 1;
  1857. byte_offset = new_byte_offset;
  1858. }
  1859. }
  1860. }
  1867. //printf("mpeg3demux_seek_time 1n");
  1870. /* Get one packet before the packet just read */
  1871. if(!result && byte_offset > 0 && minimum > 0)
  1872. {
  1873. mpeg3_read_prev_packet(demuxer);
  1874. //printf("mpeg3demux_seek_time 2n");
  1875. mpeg3_read_prev_packet(demuxer);
  1876. }
  1878. //printf("mpeg3demux_seek_time 3n");
  1881. //printf("mpeg3demux_seek_time 2 %d %d %dn", demuxer->current_title, demuxer->current_timecode, mpeg3demux_tell(demuxer));
  1882. demuxer->error_flag = result;
  1883. return result;
  1884. }
  1898. int mpeg3demux_seek_percentage(mpeg3_demuxer_t *demuxer, double percentage)
  1899. {
  1900. double total_bytes = 0;
  1901. double absolute_position;
  1902. long relative_position;
  1903. int i, new_title;
  1904. mpeg3_title_t *title;
  1906. demuxer->error_flag = 0;
  1908. /* Get the absolute byte position; */
  1909. for(i = 0; i < demuxer->total_titles; i++)
  1910. total_bytes += demuxer->titles[i]->total_bytes;
  1912. absolute_position = percentage * total_bytes;
  1920. /* Get the title the byte is inside */
  1921. for(new_title = 0, total_bytes = 0; new_title < demuxer->total_titles; new_title++)
  1922. {
  1923. total_bytes += demuxer->titles[new_title]->total_bytes;
  1924. if(absolute_position < total_bytes) break;
  1925. }
  1927. if(new_title >= demuxer->total_titles)
  1928. {
  1929. new_title = demuxer->total_titles - 1;
  1930. }
  1938. /* Got a title */
  1939. title = demuxer->titles[new_title];
  1940. total_bytes -= title->total_bytes;
  1941. relative_position = (long)(absolute_position - total_bytes);
  1950. /* Get the timecode the byte is inside */
  1951. for(demuxer->current_timecode = 0; 
  1952. demuxer->current_timecode < title->timecode_table_size; 
  1953. demuxer->current_timecode++)
  1954. {
  1955. if(title->timecode_table[demuxer->current_timecode].start_byte <= relative_position &&
  1956. title->timecode_table[demuxer->current_timecode].end_byte > relative_position)
  1957. {
  1958. break;
  1959. }
  1960. }
  1962. if(demuxer->current_timecode >= title->timecode_table_size)
  1963. demuxer->current_timecode = title->timecode_table_size - 1;
  1971. /* Get the nearest timecode in the same program */
  1972. while(demuxer->current_timecode < title->timecode_table_size - 1 &&
  1973. title->timecode_table[demuxer->current_timecode].program != demuxer->current_program)
  1974. {
  1975. demuxer->current_timecode++;
  1976. }
  1978. /*
  1979.  * printf("seek percentage 1 %d %d %d %dn", demuxer->current_title, 
  1980.  *  demuxer->current_timecode,
  1981.  *  title->timecode_table[demuxer->current_timecode].start_byte,
  1982.  *  title->timecode_table[demuxer->current_timecode].end_byte);
  1983.  */
  1985. /* Open the new title and seek to the correct byte */
  1986. if(new_title != demuxer->current_title)
  1987. {
  1988. demuxer->error_flag = mpeg3demux_open_title(demuxer, new_title);
  1989. }
  1991. /*
  1992.  * printf("seek percentage 2 %d %d %d %dn", demuxer->current_title, 
  1993.  *  demuxer->current_timecode,
  1994.  *  title->timecode_table[demuxer->current_timecode].start_byte,
  1995.  *  title->timecode_table[demuxer->current_timecode].end_byte);
  1996.  */
  1998. if(!demuxer->error_flag)
  1999. demuxer->error_flag = mpeg3io_seek(title->fs, relative_position);
  2001. return demuxer->error_flag;
  2002. }
  2005. // Lots of optimization errors
  2006. double mpeg3demux_tell_percentage(mpeg3_demuxer_t *demuxer)
  2007. {
  2008. double total_bytes = 0;
  2009. double position = 0;
  2010. int i;
  2012. demuxer->error_flag = 0;
  2013. position = mpeg3io_tell_gcc(demuxer->titles[demuxer->current_title]->fs);
  2016. for(i = 0; i < demuxer->total_titles; i++)
  2017. {
  2018. double new_bytes = mpeg3_total_bytes_gcc(demuxer->titles[i]);
  2019. if(i == demuxer->current_title)
  2020. {
  2021. position = mpeg3_add_double_gcc(total_bytes, position);
  2022. }
  2023. total_bytes = mpeg3_add_double_gcc(total_bytes, new_bytes);
  2024. }
  2026. return position / total_bytes;
  2027. }
  2029. double mpeg3demux_get_time(mpeg3_demuxer_t *demuxer)
  2030. {
  2031. return demuxer->time;
  2032. }
  2034. int64_t mpeg3demux_tell(mpeg3_demuxer_t *demuxer)
  2035. {
  2036. return mpeg3io_tell(demuxer->titles[demuxer->current_title]->fs);
  2037. }
  2039. int mpeg3demux_tell_title(mpeg3_demuxer_t *demuxer)
  2040. {
  2041. return demuxer->current_title;
  2042. }
  2044. int64_t mpeg3demuxer_total_bytes(mpeg3_demuxer_t *demuxer)
  2045. {
  2046. mpeg3_title_t *title = demuxer->titles[demuxer->current_title];
  2047. return title->total_bytes;
  2048. }
  2050. mpeg3_demuxer_t* mpeg3_get_demuxer(mpeg3_t *file)
  2051. {
  2052. if(file->is_program_stream || file->is_transport_stream)
  2053. {
  2054. if(file->total_astreams) return file->atrack[0]->demuxer;
  2055. else
  2056. if(file->total_vstreams) return file->vtrack[0]->demuxer;
  2057. }
  2058. return 0;
  2059. }