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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

libmpeg3.c：源码内容
  1. #include "libmpeg3.h"
  2. #include "mpeg3protos.h"
  4. #include <fcntl.h>
  5. #include <stdlib.h>
  6. #include <string.h>
  8. #ifndef MAX
  9. #define MAX(a, b) ((a) > (b) ? (a) : (b))
  10. #endif
  12. mpeg3_t* mpeg3_new(const char *path)
  13. {
  14. int i;
  15. mpeg3_t *file = calloc(1, sizeof(mpeg3_t));
  16. file->cpus = 1;
  17. file->fs = mpeg3_new_fs(path);
  18. file->demuxer = mpeg3_new_demuxer(file, 0, 0, -1);
  19. file->seekable = 1;
  20. return file;
  21. }
  23. int mpeg3_delete(mpeg3_t *file)
  24. {
  25. int i;
  27. for(i = 0; i < file->total_vstreams; i++)
  28. mpeg3_delete_vtrack(file, file->vtrack[i]);
  30. for(i = 0; i < file->total_astreams; i++)
  31. mpeg3_delete_atrack(file, file->atrack[i]);
  33. mpeg3_delete_fs(file->fs);
  34. mpeg3_delete_demuxer(file->demuxer);
  36. if(file->frame_offsets)
  37. {
  38. for(i = 0; i < file->total_vstreams; i++)
  39. {
  40. free(file->frame_offsets[i]);
  41. free(file->keyframe_numbers[i]);
  42. }
  44. free(file->frame_offsets);
  45. free(file->keyframe_numbers);
  46. free(file->total_frame_offsets);
  47. free(file->total_keyframe_numbers);
  48. }
  50. if(file->sample_offsets)
  51. {
  52. for(i = 0; i < file->total_astreams; i++)
  53. free(file->sample_offsets[i]);
  55. free(file->sample_offsets);
  56. free(file->total_sample_offsets);
  57. }
  59. free(file);
  60. return 0;
  61. }
  63. int mpeg3_check_sig(const char *path)
  64. {
  65. mpeg3_fs_t *fs;
  66. u_int32_t bits;
  67. char *ext;
  68. int result = 0;
  70. fs = mpeg3_new_fs(path);
  71. if(mpeg3io_open_file(fs))
  72. {
  73. /* File not found */
  74. return 0;
  75. }
  77. bits = mpeg3io_read_int32(fs);
  78. /* Test header */
  79. if(bits == MPEG3_TOC_PREFIX)
  80. {
  81. result = 1;
  82. }
  83. else
  84. if((((bits >> 24) & 0xff) == MPEG3_SYNC_BYTE) ||
  85. (bits == MPEG3_PACK_START_CODE) ||
  86. ((bits & 0xfff00000) == 0xfff00000) ||
  87. ((bits & 0xffff0000) == 0xffe30000) ||
  88. (bits == MPEG3_SEQUENCE_START_CODE) ||
  89. (bits == MPEG3_PICTURE_START_CODE) ||
  90. (((bits & 0xffff0000) >> 16) == MPEG3_AC3_START_CODE) ||
  91. ((bits >> 8) == MPEG3_ID3_PREFIX) ||
  92. (bits == MPEG3_RIFF_CODE) ||
  93.         (bits == MPEG3_IFO_PREFIX))
  94. {
  95. result = 1;
  97. ext = strrchr(path, '.');
  98. if(ext)
  99. {
  100. /* Test file extension. */
  101. if(strncasecmp(ext, ".ifo", 4) && 
  102.              strncasecmp(ext, ".mp2", 4) && 
  103. strncasecmp(ext, ".mp3", 4) &&
  104. strncasecmp(ext, ".m1v", 4) &&
  105. strncasecmp(ext, ".m2v", 4) &&
  106. strncasecmp(ext, ".m2s", 4) &&
  107. strncasecmp(ext, ".mpg", 4) &&
  108. strncasecmp(ext, ".vob", 4) &&
  109. strncasecmp(ext, ".mpeg", 4) &&
  110. strncasecmp(ext, ".ac3", 4))
  111. result = 0;
  112. }
  113. }
  115. mpeg3io_close_file(fs);
  116. mpeg3_delete_fs(fs);
  117. return result;
  118. }
  121. static uint32_t read_int32(unsigned char *buffer, int *position)
  122. {
  123. uint32_t temp;
  125. if(MPEG3_LITTLE_ENDIAN)
  126. {
  127. ((unsigned char*)&temp)[3] = buffer[(*position)++];
  128. ((unsigned char*)&temp)[2] = buffer[(*position)++];
  129. ((unsigned char*)&temp)[1] = buffer[(*position)++];
  130. ((unsigned char*)&temp)[0] = buffer[(*position)++];
  131. }
  132. else
  133. {
  134. ((unsigned char*)&temp)[0] = buffer[(*position)++];
  135. ((unsigned char*)&temp)[1] = buffer[(*position)++];
  136. ((unsigned char*)&temp)[2] = buffer[(*position)++];
  137. ((unsigned char*)&temp)[3] = buffer[(*position)++];
  138. }
  140. return temp;
  141. }
  143. static uint64_t read_int64(unsigned char *buffer, int *position)
  144. {
  145. uint64_t temp;
  147. if(MPEG3_LITTLE_ENDIAN)
  148. {
  149. ((unsigned char*)&temp)[7] = buffer[(*position)++];
  150. ((unsigned char*)&temp)[6] = buffer[(*position)++];
  151. ((unsigned char*)&temp)[5] = buffer[(*position)++];
  152. ((unsigned char*)&temp)[4] = buffer[(*position)++];
  153. ((unsigned char*)&temp)[3] = buffer[(*position)++];
  154. ((unsigned char*)&temp)[2] = buffer[(*position)++];
  155. ((unsigned char*)&temp)[1] = buffer[(*position)++];
  156. ((unsigned char*)&temp)[0] = buffer[(*position)++];
  157. }
  158. else
  159. {
  160. ((unsigned char*)&temp)[0] = buffer[(*position)++];
  161. ((unsigned char*)&temp)[1] = buffer[(*position)++];
  162. ((unsigned char*)&temp)[2] = buffer[(*position)++];
  163. ((unsigned char*)&temp)[3] = buffer[(*position)++];
  164. ((unsigned char*)&temp)[4] = buffer[(*position)++];
  165. ((unsigned char*)&temp)[5] = buffer[(*position)++];
  166. ((unsigned char*)&temp)[6] = buffer[(*position)++];
  167. ((unsigned char*)&temp)[7] = buffer[(*position)++];
  168. }
  170. return temp;
  171. }
  178. static int read_toc(mpeg3_t *file)
  179. {
  180. unsigned char *buffer;
  181. int file_type;
  182. int position = 4;
  183. int stream_type;
  184. int atracks;
  185. int vtracks;
  186. int i, j;
  188. buffer = malloc(mpeg3io_total_bytes(file->fs));
  189. mpeg3io_seek(file->fs, 0);
  190. mpeg3io_read_data(buffer, mpeg3io_total_bytes(file->fs), file->fs);
  193. //printf("read_toc %lldn", mpeg3io_total_bytes(file->fs));
  195. // File type
  196. file_type = buffer[position++];
  197. switch(file_type)
  198. {
  199. case FILE_TYPE_PROGRAM:
  200. file->is_program_stream = 1;
  201. break;
  202. case FILE_TYPE_TRANSPORT:
  203. file->is_transport_stream = 1;
  204. break;
  205. case FILE_TYPE_AUDIO:
  206. file->is_audio_stream = 1;
  207. break;
  208. case FILE_TYPE_VIDEO:
  209. file->is_video_stream = 1;
  210. break;
  211. }
  214. // Stream ID's
  215. while((stream_type = buffer[position]) != TITLE_PATH)
  216. {
  217. int offset;
  218. int stream_id;
  220. //printf("read_toc %d %xn", position, buffer[position]);
  221. position++;
  222. offset = read_int32(buffer, &position);
  223. stream_id = read_int32(buffer, &position);
  225. if(stream_type == STREAM_AUDIO)
  226. {
  227. file->demuxer->astream_table[offset] = stream_id;
  228. }
  230. if(stream_type == STREAM_VIDEO)
  231. {
  232. file->demuxer->vstream_table[offset] = stream_id;
  233. }
  234. }
  240. // Titles
  241. while(buffer[position] == TITLE_PATH)
  242. {
  243. char string[MPEG3_STRLEN];
  244. int string_len = 0;
  245. mpeg3_title_t *title;
  247. position++;
  248. while(buffer[position] != 0) string[string_len++] = buffer[position++];
  249. string[string_len++] = 0;
  250. position++;
  252. title = 
  253. file->demuxer->titles[file->demuxer->total_titles++] = 
  254. mpeg3_new_title(file, string);
  256. title->total_bytes = read_int64(buffer, &position);
  258. // Cells
  259. title->timecode_table_size = 
  260. title->timecode_table_allocation = 
  261. read_int32(buffer, &position);
  262. title->timecode_table = calloc(title->timecode_table_size, sizeof(mpeg3demux_timecode_t));
  263. for(i = 0; i < title->timecode_table_size; i++)
  264. {
  265. title->timecode_table[i].start_byte = read_int64(buffer, &position);
  266. title->timecode_table[i].end_byte = read_int64(buffer, &position);
  267. title->timecode_table[i].program = read_int32(buffer, &position);
  268. }
  269. }
  273. // Audio streams
  274. // Skip ATRACK_COUNT
  275. position++;
  276. atracks = read_int32(buffer, &position);
  278. // Skip VTRACK_COUNT
  279. position++;
  280. vtracks = read_int32(buffer, &position);
  283. if(atracks)
  284. {
  285. file->sample_offsets = malloc(sizeof(int64_t*) * atracks);
  286. file->total_sample_offsets = malloc(sizeof(int*) * atracks);
  288. for(i = 0; i < atracks; i++)
  289. {
  290. file->total_sample_offsets[i] = read_int32(buffer, &position);
  291. file->sample_offsets[i] = malloc(file->total_sample_offsets[i] * sizeof(int64_t));
  292. for(j = 0; j < file->total_sample_offsets[i]; j++)
  293. {
  294. file->sample_offsets[i][j] = read_int64(buffer, &position);
  295. //printf("samples %llxn", file->sample_offsets[i][j]);
  296. }
  297. }
  298. }
  300. if(vtracks)
  301. {
  302. file->frame_offsets = malloc(sizeof(int64_t*) * vtracks);
  303. file->total_frame_offsets = malloc(sizeof(int*) * vtracks);
  304. file->keyframe_numbers = malloc(sizeof(int64_t*) * vtracks);
  305. file->total_keyframe_numbers = malloc(sizeof(int*) * vtracks);
  307. for(i = 0; i < vtracks; i++)
  308. {
  309. file->total_frame_offsets[i] = read_int32(buffer, &position);
  310. file->frame_offsets[i] = malloc(file->total_frame_offsets[i] * sizeof(int64_t));
  311. for(j = 0; j < file->total_frame_offsets[i]; j++)
  312. {
  313. file->frame_offsets[i][j] = read_int64(buffer, &position);
  314. //printf("frame %llxn", file->frame_offsets[i][j]);
  315. }
  318. file->total_keyframe_numbers[i] = read_int32(buffer, &position);
  319. file->keyframe_numbers[i] = malloc(file->total_keyframe_numbers[i] * sizeof(int64_t));
  320. for(j = 0; j < file->total_keyframe_numbers[i]; j++)
  321. {
  322. file->keyframe_numbers[i][j] = read_int64(buffer, &position);
  323. }
  324. }
  325. }
  327. free(buffer);
  331. //printf("read_toc 1n");
  332. mpeg3demux_open_title(file->demuxer, 0);
  334. //printf("read_toc 2 %llxn", mpeg3demux_tell(file->demuxer));
  335. return 0;
  336. }
  341. mpeg3_t* mpeg3_open_copy(const char *path, mpeg3_t *old_file)
  342. {
  343. mpeg3_t *file = 0;
  344. unsigned int bits;
  345. int i, done;
  347. /* Initialize the file structure */
  348. file = mpeg3_new(path);
  356. //printf("mpeg3_open_copy %sn", path);
  358. /* Need to perform authentication before reading a single byte. */
  359. if(mpeg3io_open_file(file->fs))
  360. {
  361. mpeg3_delete(file);
  362. return 0;
  363. }
  377. /* =============================== Create the title objects ========================= */
  378. bits = mpeg3io_read_int32(file->fs);
  379. //printf("mpeg3_open 1 %p %d %d %d %dn", old_file, file->is_transport_stream, file->is_program_stream, file->is_video_stream, file->is_audio_stream);
  381. if(bits == MPEG3_TOC_PREFIX)   /* TOC  */
  382. {
  383. /* Table of contents for another title set */
  384. if(!old_file)
  385. {
  386. //printf("libmpeg3 1n");
  387. if(read_toc(file))
  388. {
  389. //printf("libmpeg3 1n");
  390. mpeg3io_close_file(file->fs);
  391. mpeg3_delete(file);
  392. return 0;
  393. }
  394. //printf("libmpeg3 1n");
  395. }
  396. mpeg3io_close_file(file->fs);
  397. }
  398. else
  399. // IFO file
  400. #ifndef _WIN32
  401.     if(bits == MPEG3_IFO_PREFIX)
  402.     {
  403. //printf("libmpeg3 1n");
  404.      if(!old_file)
  405. {
  406. //printf("libmpeg3 2n");
  407. if(mpeg3_read_ifo(file, 0))
  408.          {
  409. mpeg3_delete(file);
  410. mpeg3io_close_file(file->fs);
  411. return 0;
  412.          }
  413. //printf("libmpeg3 3n");
  414. }
  415. file->is_ifo_file = 1;
  416. mpeg3io_close_file(file->fs);
  417.     }
  418.     else
  419. #endif
  420. if(((bits >> 24) & 0xff) == MPEG3_SYNC_BYTE)
  421. {
  422. /* Transport stream */
  423. //printf("libmpeg3 2n");
  424. file->is_transport_stream = 1;
  425. }
  426. else
  427. if(bits == MPEG3_PACK_START_CODE)
  428. {
  429. /* Program stream */
  430. /* Determine packet size empirically */
  431. //printf("libmpeg3 3n");
  432. file->is_program_stream = 1;
  433. }
  434. else
  435. if((bits & 0xfff00000) == 0xfff00000 ||
  436. (bits & 0xffff0000) == 0xffe30000 ||
  437. ((bits >> 8) == MPEG3_ID3_PREFIX) ||
  438. (bits == MPEG3_RIFF_CODE))
  439. {
  440. /* MPEG Audio only */
  441. //printf("libmpeg3 4n");
  442. file->is_audio_stream = 1;
  443. }
  444. else
  445. if(bits == MPEG3_SEQUENCE_START_CODE ||
  446. bits == MPEG3_PICTURE_START_CODE)
  447. {
  448. /* Video only */
  449. //printf("libmpeg3 5n");
  450. file->is_video_stream = 1;
  451. }
  452. else
  453. if(((bits & 0xffff0000) >> 16) == MPEG3_AC3_START_CODE)
  454. {
  455. /* AC3 Audio only */
  456. //printf("libmpeg3 6n");
  457. file->is_audio_stream = 1;
  458. }
  459. else
  460. {
  461. //printf("libmpeg3 7n");
  462. mpeg3_delete(file);
  463. fprintf(stderr, "mpeg3_open: not an MPEG 2 streamn");
  464. return 0;
  465. }
  467. //printf("mpeg3_open 2 %p %d %d %d %dn", 
  468. // old_file, file->is_transport_stream, file->is_program_stream, file->is_video_stream, file->is_audio_stream);
  482. // Configure packet size
  483. if(file->is_transport_stream)
  484. file->packet_size = MPEG3_TS_PACKET_SIZE;
  485. else
  486. if(file->is_program_stream)
  487. file->packet_size = 0;
  488. else
  489. if(file->is_audio_stream)
  490. file->packet_size = MPEG3_DVD_PACKET_SIZE;
  491. else
  492. if(file->is_video_stream)
  493. file->packet_size = MPEG3_DVD_PACKET_SIZE;
  507. //printf("mpeg3_open 1n");
  509. /* Create titles */
  510. /* Copy timecodes from an old demuxer */
  511. if(old_file && mpeg3_get_demuxer(old_file))
  512. {
  513. mpeg3demux_copy_titles(file->demuxer, mpeg3_get_demuxer(old_file));
  514. file->is_transport_stream = old_file->is_transport_stream;
  515. file->is_program_stream = old_file->is_program_stream;
  516. }
  517. else
  518. /* Start from scratch */
  519. if(!file->demuxer->total_titles)
  520. {
  521. mpeg3demux_create_title(file->demuxer, 0, 0);
  522. }
  526. //printf("mpeg3_open 2n");
  538. /* Generate tracks */
  539. if(file->is_transport_stream || file->is_program_stream)
  540. {
  541. /* Create video tracks */
  542. /* Video must be created before audio because audio uses the video timecode */
  543. /* to get its length. */
  544. for(i = 0; i < MPEG3_MAX_STREAMS; i++)
  545. {
  546. if(file->demuxer->vstream_table[i])
  547. {
  548. file->vtrack[file->total_vstreams] = 
  549. mpeg3_new_vtrack(file, 
  550. i, 
  551. file->demuxer, 
  552. file->total_vstreams);
  553. if(file->vtrack[file->total_vstreams]) 
  554. file->total_vstreams++;
  556. //printf("libmpeg3 %d %d %p %dn", i, file->demuxer->vstream_table[i], file->vtrack[file->total_vstreams], file->total_vstreams);
  557. }
  558. }
  560. /* Create audio tracks */
  561. for(i = 0; i < MPEG3_MAX_STREAMS; i++)
  562. {
  563. if(file->demuxer->astream_table[i])
  564. {
  565. file->atrack[file->total_astreams] = mpeg3_new_atrack(file, 
  566. i, 
  567. file->demuxer->astream_table[i], 
  568. file->demuxer,
  569. file->total_astreams);
  570. if(file->atrack[file->total_astreams]) file->total_astreams++;
  571. }
  572. }
  573. }
  574. else
  575. if(file->is_video_stream)
  576. {
  577. /* Create video tracks */
  578. //printf("mpeg3_open 3n");
  579. file->vtrack[0] = mpeg3_new_vtrack(file, 
  580. -1, 
  581. file->demuxer, 
  582. 0);
  583. //printf("mpeg3_open 4n");
  584. if(file->vtrack[0]) file->total_vstreams++;
  585. }
  586. else
  587. if(file->is_audio_stream)
  588. {
  589. /* Create audio tracks */
  591. //printf("mpeg3_open 3n");
  592. file->atrack[0] = mpeg3_new_atrack(file, 
  593. -1, 
  594. AUDIO_UNKNOWN, 
  595. file->demuxer,
  596. 0);
  597. //printf("mpeg3_open 3n");
  598. if(file->atrack[0]) file->total_astreams++;
  599. }
  601. //printf("mpeg3_open 5n");
  605. mpeg3io_close_file(file->fs);
  606. return file;
  607. }
  609. mpeg3_t* mpeg3_open(const char *path)
  610. {
  611. return mpeg3_open_copy(path, 0);
  612. }
  614. int mpeg3_close(mpeg3_t *file)
  615. {
  616. /* File is closed in the same procedure it is opened in. */
  617. mpeg3_delete(file);
  618. return 0;
  619. }
  622. int mpeg3_has_audio(mpeg3_t *file)
  623. {
  624. return file->total_astreams > 0;
  625. }
  627. int mpeg3_total_astreams(mpeg3_t *file)
  628. {
  629. return file->total_astreams;
  630. }
  632. int mpeg3_audio_channels(mpeg3_t *file,
  633. int stream)
  634. {
  635. if(file->total_astreams)
  636. return file->atrack[stream]->channels;
  637. return -1;
  638. }
  640. int mpeg3_sample_rate(mpeg3_t *file,
  641. int stream)
  642. {
  643. if(file->total_astreams)
  644. return file->atrack[stream]->sample_rate;
  645. return -1;
  646. }
  648. int mpeg3_audio_samples_per_frame(mpeg3_t *file,
  649. int stream)
  650. {
  651. if(file->total_astreams)
  652. return file->atrack[stream]->samples_per_frame;
  653. return -1;
  654. }
  656. uint32_t mpeg3_audio_get_number_of_frames (mpeg3_t *file, 
  657.    int stream)
  658. {
  659.   if (file->total_astreams) 
  660.     return file->atrack[stream]->total_frames;
  661.   return -1;
  662. }
  664. char* mpeg3_audio_format(mpeg3_t *file, int stream)
  665. {
  666. if(stream < file->total_astreams)
  667. {
  668. switch(file->atrack[stream]->format)
  669. {
  670. case AUDIO_UNKNOWN: return "Unknown"; break;
  671. case AUDIO_MPEG:    return "MPEG"; break;
  672. case AUDIO_AC3:     return "AC3"; break;
  673. case AUDIO_PCM:     return "PCM"; break;
  674. case AUDIO_AAC:     return "AAC"; break;
  675. case AUDIO_JESUS:   return "Vorbis"; break;
  676. }
  677. }
  678. return "";
  679. }
  681. int mpeg3_has_video(mpeg3_t *file)
  682. {
  683. return file->total_vstreams > 0;
  684. }
  686. int mpeg3_total_vstreams(mpeg3_t *file)
  687. {
  688. return file->total_vstreams;
  689. }
  691. int mpeg3_video_width(mpeg3_t *file,
  692. int stream)
  693. {
  694. if(file->total_vstreams)
  695. return file->vtrack[stream]->width;
  696. return -1;
  697. }
  699. int mpeg3_video_height(mpeg3_t *file,
  700. int stream)
  701. {
  702. if(file->total_vstreams)
  703. return file->vtrack[stream]->height;
  704. return -1;
  705. }
  707. float mpeg3_aspect_ratio(mpeg3_t *file, int stream)
  708. {
  709. if(file->total_vstreams)
  710. return file->vtrack[stream]->aspect_ratio;
  711. return 0;
  712. }
  714. float mpeg3_frame_rate(mpeg3_t *file,
  715. int stream)
  716. {
  717. if(file->total_vstreams)
  718. return file->vtrack[stream]->frame_rate;
  719. return -1;
  720. }
  722. long mpeg3_video_frames(mpeg3_t *file,
  723. int stream)
  724. {
  725. if(file->total_vstreams)
  726. return file->vtrack[stream]->total_frames;
  727. return -1;
  728. }
  730. long mpeg3_get_frame(mpeg3_t *file,
  731. int stream)
  732. {
  733. if(file->total_vstreams)
  734. return file->vtrack[stream]->current_position;
  735. return -1;
  736. }
  738. int mpeg3_set_frame(mpeg3_t *file, 
  739. long frame,
  740. int stream)
  741. {
  742. if(file->total_vstreams)
  743. {
  744.   file->vtrack[stream]->current_position = frame;
  745. mpeg3vtrack_seek_frame(file->vtrack[stream], frame);
  746. return 0;
  747. }
  748. return -1;
  749. }
  751. int mpeg3_seek_percentage(mpeg3_t *file, double percentage)
  752. {
  753. int i;
  754. for(i = 0; i < file->total_vstreams; i++)
  755. {
  756. mpeg3vtrack_seek_percentage(file->vtrack[i], percentage);
  757. }
  759. for(i = 0; i < file->total_astreams; i++)
  760. {
  761.   mpeg3atrack_seek_percentage(file->atrack[i], percentage);
  762. }
  764. return 0;
  765. }
  767. int mpeg3_seek_audio_percentage(mpeg3_t *file, int stream, double percentage)
  768. {
  769.   mpeg3atrack_seek_percentage(file->atrack[stream], percentage);
  770.   return 0;
  771. }
  773. int mpeg3_seek_video_percentage(mpeg3_t *file, int stream, double percentage)
  774. {
  775.   mpeg3vtrack_seek_percentage(file->vtrack[stream], percentage);
  776.   return 0;
  777. }
  779. #if 0
  780. int mpeg3_previous_frame(mpeg3_t *file, int stream)
  781. {
  782. file->last_type_read = 2;
  783. file->last_stream_read = stream;
  785. if(file->total_vstreams)
  786. return mpeg3video_previous_frame(file->vtrack[stream]->video);
  788. return 0;
  789. }
  790. #endif
  792. double mpeg3_tell_percentage(mpeg3_t *file)
  793. {
  794. double percent = 0;
  795. if(file->last_type_read == 1)
  796. {
  797. percent = mpeg3demux_tell_percentage(file->atrack[file->last_stream_read]->demuxer);
  798. }
  800. if(file->last_type_read == 2)
  801. {
  802. percent = mpeg3demux_tell_percentage(file->vtrack[file->last_stream_read]->demuxer);
  803. }
  804. return percent;
  805. }
  808. int mpeg3_end_of_audio(mpeg3_t *file, int stream)
  809. {
  810. int result = 0;
  811. result = mpeg3demux_eof(file->atrack[stream]->demuxer);
  812. return result;
  813. }
  815. int mpeg3_end_of_video(mpeg3_t *file, int stream)
  816. {
  817. int result = 0;
  818. result = mpeg3demux_eof(file->vtrack[stream]->demuxer);
  819. return result;
  820. }
  824. int mpeg3_read_audio_frame (mpeg3_t *file,
  825.     unsigned char **output,
  826.     uint32_t *size,
  827.     uint32_t *max_size,
  828.     int stream)
  829. {
  830.   int result = -1;
  831.   if (file->total_astreams) {
  832.     result = mpeg3_atrack_read_frame(file->atrack[stream],
  833.      output, 
  834.      size,
  835.      max_size);
  836.     file->last_type_read = 1;
  837.     file->last_stream_read = stream;
  839.   }
  840.   return result;
  841. }
  842.  
  843. int mpeg3_get_audio_format (mpeg3_t *file, int stream)
  844. {
  845.   if (file->total_astreams) {
  846.     return (file->atrack[stream]->format);
  847.   }
  848.   return AUDIO_UNKNOWN;
  849. }
  850. int mpeg3_read_video_chunk(mpeg3_t *file, 
  851. unsigned char *output, 
  852. long *size, 
  853. long max_size,
  854. int stream)
  855. {
  856. int result = 0;
  857. if(file->total_vstreams)
  858. {
  859. result = mpeg3vtrack_read_raw(file->vtrack[stream], output, size, max_size);
  860. file->last_type_read = 2;
  861. file->last_stream_read = stream;
  862. }
  863. return result;
  864. }
  866. int mpeg3_read_video_chunk_resize (mpeg3_t *file,
  867.    unsigned char **output,
  868.    long *size,
  869.    int stream)
  870. {
  871. int result = 0;
  872. if(file->total_vstreams)
  873. {
  874. result = mpeg3vtrack_read_raw_resize(file->vtrack[stream], 
  875.      output, 
  876.      size);
  877. file->last_type_read = 2;
  878. file->last_stream_read = stream;
  879. }
  880. return result;
  881. }
  882. void mpeg3_read_video_chunk_cleanup (mpeg3_t *file,
  883.      int stream)
  884. {
  885. int result = 0;
  886. if(file->total_vstreams)
  887. {
  888.   mpeg3vtrack_cleanup_frame(file->vtrack[stream]);
  889. }
  890. }