You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

709 lines
20KB

  1. /*
  2. * MPEG1/2 mux/demux
  3. * Copyright (c) 2000, 2001, 2002 Fabrice Bellard.
  4. *
  5. * This library is free software; you can redistribute it and/or
  6. * modify it under the terms of the GNU Lesser General Public
  7. * License as published by the Free Software Foundation; either
  8. * version 2 of the License, or (at your option) any later version.
  9. *
  10. * This library is distributed in the hope that it will be useful,
  11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  13. * Lesser General Public License for more details.
  14. *
  15. * You should have received a copy of the GNU Lesser General Public
  16. * License along with this library; if not, write to the Free Software
  17. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  18. */
  19. #include "avformat.h"
  20. #define MAX_PAYLOAD_SIZE 4096
  21. #define NB_STREAMS 2
  22. typedef struct {
  23. uint8_t buffer[MAX_PAYLOAD_SIZE];
  24. int buffer_ptr;
  25. uint8_t id;
  26. int max_buffer_size; /* in bytes */
  27. int packet_number;
  28. int64_t start_pts;
  29. } StreamInfo;
  30. typedef struct {
  31. int packet_size; /* required packet size */
  32. int packet_data_max_size; /* maximum data size inside a packet */
  33. int packet_number;
  34. int pack_header_freq; /* frequency (in packets^-1) at which we send pack headers */
  35. int system_header_freq;
  36. int mux_rate; /* bitrate in units of 50 bytes/s */
  37. /* stream info */
  38. int audio_bound;
  39. int video_bound;
  40. int is_mpeg2;
  41. int is_vcd;
  42. } MpegMuxContext;
  43. #define PACK_START_CODE ((unsigned int)0x000001ba)
  44. #define SYSTEM_HEADER_START_CODE ((unsigned int)0x000001bb)
  45. #define SEQUENCE_END_CODE ((unsigned int)0x000001b7)
  46. #define PACKET_START_CODE_MASK ((unsigned int)0xffffff00)
  47. #define PACKET_START_CODE_PREFIX ((unsigned int)0x00000100)
  48. #define ISO_11172_END_CODE ((unsigned int)0x000001b9)
  49. /* mpeg2 */
  50. #define PROGRAM_STREAM_MAP 0x1bc
  51. #define PRIVATE_STREAM_1 0x1bd
  52. #define PADDING_STREAM 0x1be
  53. #define PRIVATE_STREAM_2 0x1bf
  54. #define AUDIO_ID 0xc0
  55. #define VIDEO_ID 0xe0
  56. extern AVOutputFormat mpeg1system_mux;
  57. extern AVOutputFormat mpeg1vcd_mux;
  58. extern AVOutputFormat mpeg2vob_mux;
  59. static int put_pack_header(AVFormatContext *ctx,
  60. uint8_t *buf, int64_t timestamp)
  61. {
  62. MpegMuxContext *s = ctx->priv_data;
  63. PutBitContext pb;
  64. init_put_bits(&pb, buf, 128, NULL, NULL);
  65. put_bits(&pb, 32, PACK_START_CODE);
  66. if (s->is_mpeg2) {
  67. put_bits(&pb, 2, 0x2);
  68. } else {
  69. put_bits(&pb, 4, 0x2);
  70. }
  71. put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07));
  72. put_bits(&pb, 1, 1);
  73. put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
  74. put_bits(&pb, 1, 1);
  75. put_bits(&pb, 15, (uint32_t)((timestamp) & 0x7fff));
  76. put_bits(&pb, 1, 1);
  77. if (s->is_mpeg2) {
  78. /* clock extension */
  79. put_bits(&pb, 9, 0);
  80. put_bits(&pb, 1, 1);
  81. }
  82. put_bits(&pb, 1, 1);
  83. put_bits(&pb, 22, s->mux_rate);
  84. put_bits(&pb, 1, 1);
  85. if (s->is_mpeg2) {
  86. put_bits(&pb, 5, 0x1f); /* reserved */
  87. put_bits(&pb, 3, 0); /* stuffing length */
  88. }
  89. flush_put_bits(&pb);
  90. return pbBufPtr(&pb) - pb.buf;
  91. }
  92. static int put_system_header(AVFormatContext *ctx, uint8_t *buf)
  93. {
  94. MpegMuxContext *s = ctx->priv_data;
  95. int size, rate_bound, i, private_stream_coded, id;
  96. PutBitContext pb;
  97. init_put_bits(&pb, buf, 128, NULL, NULL);
  98. put_bits(&pb, 32, SYSTEM_HEADER_START_CODE);
  99. put_bits(&pb, 16, 0);
  100. put_bits(&pb, 1, 1);
  101. rate_bound = s->mux_rate; /* maximum bit rate of the multiplexed stream */
  102. put_bits(&pb, 22, rate_bound);
  103. put_bits(&pb, 1, 1); /* marker */
  104. put_bits(&pb, 6, s->audio_bound);
  105. put_bits(&pb, 1, 1); /* variable bitrate */
  106. put_bits(&pb, 1, 1); /* non constrainted bit stream */
  107. put_bits(&pb, 1, 0); /* audio locked */
  108. put_bits(&pb, 1, 0); /* video locked */
  109. put_bits(&pb, 1, 1); /* marker */
  110. put_bits(&pb, 5, s->video_bound);
  111. put_bits(&pb, 8, 0xff); /* reserved byte */
  112. /* audio stream info */
  113. private_stream_coded = 0;
  114. for(i=0;i<ctx->nb_streams;i++) {
  115. StreamInfo *stream = ctx->streams[i]->priv_data;
  116. id = stream->id;
  117. if (id < 0xc0) {
  118. /* special case for private streams (AC3 use that) */
  119. if (private_stream_coded)
  120. continue;
  121. private_stream_coded = 1;
  122. id = 0xbd;
  123. }
  124. put_bits(&pb, 8, id); /* stream ID */
  125. put_bits(&pb, 2, 3);
  126. if (id < 0xe0) {
  127. /* audio */
  128. put_bits(&pb, 1, 0);
  129. put_bits(&pb, 13, stream->max_buffer_size / 128);
  130. } else {
  131. /* video */
  132. put_bits(&pb, 1, 1);
  133. put_bits(&pb, 13, stream->max_buffer_size / 1024);
  134. }
  135. }
  136. flush_put_bits(&pb);
  137. size = pbBufPtr(&pb) - pb.buf;
  138. /* patch packet size */
  139. buf[4] = (size - 6) >> 8;
  140. buf[5] = (size - 6) & 0xff;
  141. return size;
  142. }
  143. static int mpeg_mux_init(AVFormatContext *ctx)
  144. {
  145. MpegMuxContext *s = ctx->priv_data;
  146. int bitrate, i, mpa_id, mpv_id, ac3_id;
  147. AVStream *st;
  148. StreamInfo *stream;
  149. s->packet_number = 0;
  150. s->is_vcd = (ctx->oformat == &mpeg1vcd_mux);
  151. s->is_mpeg2 = (ctx->oformat == &mpeg2vob_mux);
  152. if (s->is_vcd)
  153. s->packet_size = 2324; /* VCD packet size */
  154. else
  155. s->packet_size = 2048;
  156. /* startcode(4) + length(2) + flags(1) */
  157. s->packet_data_max_size = s->packet_size - 7;
  158. s->audio_bound = 0;
  159. s->video_bound = 0;
  160. mpa_id = AUDIO_ID;
  161. ac3_id = 0x80;
  162. mpv_id = VIDEO_ID;
  163. for(i=0;i<ctx->nb_streams;i++) {
  164. st = ctx->streams[i];
  165. stream = av_mallocz(sizeof(StreamInfo));
  166. if (!stream)
  167. goto fail;
  168. st->priv_data = stream;
  169. switch(st->codec.codec_type) {
  170. case CODEC_TYPE_AUDIO:
  171. if (st->codec.codec_id == CODEC_ID_AC3)
  172. stream->id = ac3_id++;
  173. else
  174. stream->id = mpa_id++;
  175. stream->max_buffer_size = 4 * 1024;
  176. s->audio_bound++;
  177. break;
  178. case CODEC_TYPE_VIDEO:
  179. stream->id = mpv_id++;
  180. stream->max_buffer_size = 46 * 1024;
  181. s->video_bound++;
  182. break;
  183. default:
  184. av_abort();
  185. }
  186. }
  187. /* we increase slightly the bitrate to take into account the
  188. headers. XXX: compute it exactly */
  189. bitrate = 2000;
  190. for(i=0;i<ctx->nb_streams;i++) {
  191. st = ctx->streams[i];
  192. bitrate += st->codec.bit_rate;
  193. }
  194. s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
  195. if (s->is_vcd || s->is_mpeg2)
  196. /* every packet */
  197. s->pack_header_freq = 1;
  198. else
  199. /* every 2 seconds */
  200. s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
  201. if (s->is_mpeg2)
  202. /* every 200 packets. Need to look at the spec. */
  203. s->system_header_freq = s->pack_header_freq * 40;
  204. else if (s->is_vcd)
  205. /* every 40 packets, this is my invention */
  206. s->system_header_freq = s->pack_header_freq * 40;
  207. else
  208. s->system_header_freq = s->pack_header_freq * 5;
  209. for(i=0;i<ctx->nb_streams;i++) {
  210. stream = ctx->streams[i]->priv_data;
  211. stream->buffer_ptr = 0;
  212. stream->packet_number = 0;
  213. stream->start_pts = -1;
  214. }
  215. return 0;
  216. fail:
  217. for(i=0;i<ctx->nb_streams;i++) {
  218. av_free(ctx->streams[i]->priv_data);
  219. }
  220. return -ENOMEM;
  221. }
  222. /* flush the packet on stream stream_index */
  223. static void flush_packet(AVFormatContext *ctx, int stream_index, int last_pkt)
  224. {
  225. MpegMuxContext *s = ctx->priv_data;
  226. StreamInfo *stream = ctx->streams[stream_index]->priv_data;
  227. uint8_t *buf_ptr;
  228. int size, payload_size, startcode, id, len, stuffing_size, i, header_len;
  229. int64_t timestamp;
  230. uint8_t buffer[128];
  231. int last = last_pkt ? 4 : 0;
  232. id = stream->id;
  233. timestamp = stream->start_pts;
  234. #if 0
  235. printf("packet ID=%2x PTS=%0.3f\n",
  236. id, timestamp / 90000.0);
  237. #endif
  238. buf_ptr = buffer;
  239. if (((s->packet_number % s->pack_header_freq) == 0)) {
  240. /* output pack and systems header if needed */
  241. size = put_pack_header(ctx, buf_ptr, timestamp);
  242. buf_ptr += size;
  243. if ((s->packet_number % s->system_header_freq) == 0) {
  244. size = put_system_header(ctx, buf_ptr);
  245. buf_ptr += size;
  246. }
  247. }
  248. size = buf_ptr - buffer;
  249. put_buffer(&ctx->pb, buffer, size);
  250. /* packet header */
  251. if (s->is_mpeg2) {
  252. header_len = 8;
  253. } else {
  254. header_len = 5;
  255. }
  256. payload_size = s->packet_size - (size + 6 + header_len + last);
  257. if (id < 0xc0) {
  258. startcode = PRIVATE_STREAM_1;
  259. payload_size -= 4;
  260. } else {
  261. startcode = 0x100 + id;
  262. }
  263. stuffing_size = payload_size - stream->buffer_ptr;
  264. if (stuffing_size < 0)
  265. stuffing_size = 0;
  266. put_be32(&ctx->pb, startcode);
  267. put_be16(&ctx->pb, payload_size + header_len);
  268. /* stuffing */
  269. for(i=0;i<stuffing_size;i++)
  270. put_byte(&ctx->pb, 0xff);
  271. if (s->is_mpeg2) {
  272. put_byte(&ctx->pb, 0x80); /* mpeg2 id */
  273. put_byte(&ctx->pb, 0x80); /* flags */
  274. put_byte(&ctx->pb, 0x05); /* header len (only pts is included) */
  275. }
  276. put_byte(&ctx->pb,
  277. (0x02 << 4) |
  278. (((timestamp >> 30) & 0x07) << 1) |
  279. 1);
  280. put_be16(&ctx->pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
  281. put_be16(&ctx->pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
  282. if (startcode == PRIVATE_STREAM_1) {
  283. put_byte(&ctx->pb, id);
  284. if (id >= 0x80 && id <= 0xbf) {
  285. /* XXX: need to check AC3 spec */
  286. put_byte(&ctx->pb, 1);
  287. put_byte(&ctx->pb, 0);
  288. put_byte(&ctx->pb, 2);
  289. }
  290. }
  291. if (last_pkt) {
  292. put_be32(&ctx->pb, ISO_11172_END_CODE);
  293. }
  294. /* output data */
  295. put_buffer(&ctx->pb, stream->buffer, payload_size - stuffing_size);
  296. put_flush_packet(&ctx->pb);
  297. /* preserve remaining data */
  298. len = stream->buffer_ptr - payload_size;
  299. if (len < 0)
  300. len = 0;
  301. memmove(stream->buffer, stream->buffer + stream->buffer_ptr - len, len);
  302. stream->buffer_ptr = len;
  303. s->packet_number++;
  304. stream->packet_number++;
  305. stream->start_pts = -1;
  306. }
  307. static int mpeg_mux_write_packet(AVFormatContext *ctx, int stream_index,
  308. uint8_t *buf, int size, int pts)
  309. {
  310. MpegMuxContext *s = ctx->priv_data;
  311. AVStream *st = ctx->streams[stream_index];
  312. StreamInfo *stream = st->priv_data;
  313. int len;
  314. while (size > 0) {
  315. /* set pts */
  316. if (stream->start_pts == -1) {
  317. stream->start_pts = pts;
  318. }
  319. len = s->packet_data_max_size - stream->buffer_ptr;
  320. if (len > size)
  321. len = size;
  322. memcpy(stream->buffer + stream->buffer_ptr, buf, len);
  323. stream->buffer_ptr += len;
  324. buf += len;
  325. size -= len;
  326. while (stream->buffer_ptr >= s->packet_data_max_size) {
  327. /* output the packet */
  328. if (stream->start_pts == -1)
  329. stream->start_pts = pts;
  330. flush_packet(ctx, stream_index, 0);
  331. }
  332. }
  333. return 0;
  334. }
  335. static int mpeg_mux_end(AVFormatContext *ctx)
  336. {
  337. StreamInfo *stream;
  338. int i;
  339. /* flush each packet */
  340. for(i=0;i<ctx->nb_streams;i++) {
  341. stream = ctx->streams[i]->priv_data;
  342. if (stream->buffer_ptr > 0) {
  343. if (i == (ctx->nb_streams - 1))
  344. flush_packet(ctx, i, 1);
  345. else
  346. flush_packet(ctx, i, 0);
  347. }
  348. }
  349. /* write the end header */
  350. //put_be32(&ctx->pb, ISO_11172_END_CODE);
  351. //put_flush_packet(&ctx->pb);
  352. return 0;
  353. }
  354. /*********************************************/
  355. /* demux code */
  356. #define MAX_SYNC_SIZE 100000
  357. static int mpegps_probe(AVProbeData *p)
  358. {
  359. int code;
  360. const uint8_t *d;
  361. /* we search the first start code. If it is a packet start code,
  362. then we decide it is mpeg ps. We do not send highest value to
  363. give a chance to mpegts */
  364. /* NOTE: the search range was restricted to avoid too many false
  365. detections */
  366. if (p->buf_size < 6)
  367. return 0;
  368. d = p->buf;
  369. code = (d[0] << 24) | (d[1] << 16) | (d[2] << 8) | (d[3]);
  370. if ((code & 0xffffff00) == 0x100) {
  371. if (code == PACK_START_CODE ||
  372. code == SYSTEM_HEADER_START_CODE ||
  373. (code >= 0x1e0 && code <= 0x1ef) ||
  374. (code >= 0x1c0 && code <= 0x1df) ||
  375. code == PRIVATE_STREAM_2 ||
  376. code == PROGRAM_STREAM_MAP ||
  377. code == PRIVATE_STREAM_1 ||
  378. code == PADDING_STREAM)
  379. return AVPROBE_SCORE_MAX - 1;
  380. else
  381. return 0;
  382. }
  383. return 0;
  384. }
  385. typedef struct MpegDemuxContext {
  386. int header_state;
  387. } MpegDemuxContext;
  388. static int find_start_code(ByteIOContext *pb, int *size_ptr,
  389. uint32_t *header_state)
  390. {
  391. unsigned int state, v;
  392. int val, n;
  393. state = *header_state;
  394. n = *size_ptr;
  395. while (n > 0) {
  396. if (url_feof(pb))
  397. break;
  398. v = get_byte(pb);
  399. n--;
  400. if (state == 0x000001) {
  401. state = ((state << 8) | v) & 0xffffff;
  402. val = state;
  403. goto found;
  404. }
  405. state = ((state << 8) | v) & 0xffffff;
  406. }
  407. val = -1;
  408. found:
  409. *header_state = state;
  410. *size_ptr = n;
  411. return val;
  412. }
  413. static int mpegps_read_header(AVFormatContext *s,
  414. AVFormatParameters *ap)
  415. {
  416. MpegDemuxContext *m = s->priv_data;
  417. m->header_state = 0xff;
  418. /* no need to do more */
  419. return 0;
  420. }
  421. static int64_t get_pts(ByteIOContext *pb, int c)
  422. {
  423. int64_t pts;
  424. int val;
  425. if (c < 0)
  426. c = get_byte(pb);
  427. pts = (int64_t)((c >> 1) & 0x07) << 30;
  428. val = get_be16(pb);
  429. pts |= (int64_t)(val >> 1) << 15;
  430. val = get_be16(pb);
  431. pts |= (int64_t)(val >> 1);
  432. return pts;
  433. }
  434. static int mpegps_read_packet(AVFormatContext *s,
  435. AVPacket *pkt)
  436. {
  437. MpegDemuxContext *m = s->priv_data;
  438. AVStream *st;
  439. int len, size, startcode, i, c, flags, header_len, type, codec_id;
  440. int64_t pts, dts;
  441. /* next start code (should be immediately after) */
  442. redo:
  443. m->header_state = 0xff;
  444. size = MAX_SYNC_SIZE;
  445. startcode = find_start_code(&s->pb, &size, &m->header_state);
  446. //printf("startcode=%x pos=0x%Lx\n", startcode, url_ftell(&s->pb));
  447. if (startcode < 0)
  448. return -EIO;
  449. if (startcode == PACK_START_CODE)
  450. goto redo;
  451. if (startcode == SYSTEM_HEADER_START_CODE)
  452. goto redo;
  453. if (startcode == PADDING_STREAM ||
  454. startcode == PRIVATE_STREAM_2) {
  455. /* skip them */
  456. len = get_be16(&s->pb);
  457. url_fskip(&s->pb, len);
  458. goto redo;
  459. }
  460. /* find matching stream */
  461. if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
  462. (startcode >= 0x1e0 && startcode <= 0x1ef) ||
  463. (startcode == 0x1bd)))
  464. goto redo;
  465. len = get_be16(&s->pb);
  466. pts = AV_NOPTS_VALUE;
  467. dts = AV_NOPTS_VALUE;
  468. /* stuffing */
  469. for(;;) {
  470. c = get_byte(&s->pb);
  471. len--;
  472. /* XXX: for mpeg1, should test only bit 7 */
  473. if (c != 0xff)
  474. break;
  475. }
  476. if ((c & 0xc0) == 0x40) {
  477. /* buffer scale & size */
  478. get_byte(&s->pb);
  479. c = get_byte(&s->pb);
  480. len -= 2;
  481. }
  482. if ((c & 0xf0) == 0x20) {
  483. pts = get_pts(&s->pb, c);
  484. len -= 4;
  485. } else if ((c & 0xf0) == 0x30) {
  486. pts = get_pts(&s->pb, c);
  487. dts = get_pts(&s->pb, -1);
  488. len -= 9;
  489. } else if ((c & 0xc0) == 0x80) {
  490. /* mpeg 2 PES */
  491. if ((c & 0x30) != 0) {
  492. fprintf(stderr, "Encrypted multiplex not handled\n");
  493. return -EIO;
  494. }
  495. flags = get_byte(&s->pb);
  496. header_len = get_byte(&s->pb);
  497. len -= 2;
  498. if (header_len > len)
  499. goto redo;
  500. if ((flags & 0xc0) == 0x80) {
  501. pts = get_pts(&s->pb, -1);
  502. header_len -= 5;
  503. len -= 5;
  504. } if ((flags & 0xc0) == 0xc0) {
  505. pts = get_pts(&s->pb, -1);
  506. dts = get_pts(&s->pb, -1);
  507. header_len -= 10;
  508. len -= 10;
  509. }
  510. len -= header_len;
  511. while (header_len > 0) {
  512. get_byte(&s->pb);
  513. header_len--;
  514. }
  515. }
  516. if (startcode == 0x1bd) {
  517. startcode = get_byte(&s->pb);
  518. len--;
  519. if (startcode >= 0x80 && startcode <= 0xbf) {
  520. /* audio: skip header */
  521. get_byte(&s->pb);
  522. get_byte(&s->pb);
  523. get_byte(&s->pb);
  524. len -= 3;
  525. }
  526. }
  527. /* now find stream */
  528. for(i=0;i<s->nb_streams;i++) {
  529. st = s->streams[i];
  530. if (st->id == startcode)
  531. goto found;
  532. }
  533. if (startcode >= 0x1e0 && startcode <= 0x1ef) {
  534. type = CODEC_TYPE_VIDEO;
  535. codec_id = CODEC_ID_MPEG1VIDEO;
  536. } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
  537. type = CODEC_TYPE_AUDIO;
  538. codec_id = CODEC_ID_MP2;
  539. } else if (startcode >= 0x80 && startcode <= 0x9f) {
  540. type = CODEC_TYPE_AUDIO;
  541. codec_id = CODEC_ID_AC3;
  542. } else if (startcode >= 0xa0 && startcode <= 0xbf) {
  543. type = CODEC_TYPE_AUDIO;
  544. codec_id = CODEC_ID_PCM_S16BE;
  545. } else {
  546. skip:
  547. /* skip packet */
  548. url_fskip(&s->pb, len);
  549. goto redo;
  550. }
  551. /* no stream found: add a new stream */
  552. st = av_new_stream(s, startcode);
  553. if (!st)
  554. goto skip;
  555. st->codec.codec_type = type;
  556. st->codec.codec_id = codec_id;
  557. found:
  558. if (startcode >= 0xa0 && startcode <= 0xbf) {
  559. int b1, freq;
  560. static const int lpcm_freq_tab[4] = { 48000, 96000, 44100, 32000 };
  561. /* for LPCM, we just skip the header and consider it is raw
  562. audio data */
  563. if (len <= 3)
  564. goto skip;
  565. get_byte(&s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */
  566. b1 = get_byte(&s->pb); /* quant (2), freq(2), reserved(1), channels(3) */
  567. get_byte(&s->pb); /* dynamic range control (0x80 = off) */
  568. len -= 3;
  569. freq = (b1 >> 4) & 3;
  570. st->codec.sample_rate = lpcm_freq_tab[freq];
  571. st->codec.channels = 1 + (b1 & 7);
  572. st->codec.bit_rate = st->codec.channels * st->codec.sample_rate * 2;
  573. }
  574. av_new_packet(pkt, len);
  575. //printf("\nRead Packet ID: %x PTS: %f Size: %d", startcode,
  576. // (float)pts/90000, len);
  577. get_buffer(&s->pb, pkt->data, pkt->size);
  578. pkt->pts = pts;
  579. pkt->stream_index = st->index;
  580. return 0;
  581. }
  582. static int mpegps_read_close(AVFormatContext *s)
  583. {
  584. return 0;
  585. }
  586. static AVOutputFormat mpeg1system_mux = {
  587. "mpeg",
  588. "MPEG1 System format",
  589. "video/mpeg",
  590. "mpg,mpeg",
  591. sizeof(MpegMuxContext),
  592. CODEC_ID_MP2,
  593. CODEC_ID_MPEG1VIDEO,
  594. mpeg_mux_init,
  595. mpeg_mux_write_packet,
  596. mpeg_mux_end,
  597. };
  598. static AVOutputFormat mpeg1vcd_mux = {
  599. "vcd",
  600. "MPEG1 System format (VCD)",
  601. "video/mpeg",
  602. NULL,
  603. sizeof(MpegMuxContext),
  604. CODEC_ID_MP2,
  605. CODEC_ID_MPEG1VIDEO,
  606. mpeg_mux_init,
  607. mpeg_mux_write_packet,
  608. mpeg_mux_end,
  609. };
  610. static AVOutputFormat mpeg2vob_mux = {
  611. "vob",
  612. "MPEG2 PS format (VOB)",
  613. "video/mpeg",
  614. "vob",
  615. sizeof(MpegMuxContext),
  616. CODEC_ID_MP2,
  617. CODEC_ID_MPEG1VIDEO,
  618. mpeg_mux_init,
  619. mpeg_mux_write_packet,
  620. mpeg_mux_end,
  621. };
  622. static AVInputFormat mpegps_demux = {
  623. "mpeg",
  624. "MPEG PS format",
  625. sizeof(MpegDemuxContext),
  626. mpegps_probe,
  627. mpegps_read_header,
  628. mpegps_read_packet,
  629. mpegps_read_close,
  630. .flags = AVFMT_NOHEADER,
  631. };
  632. int mpegps_init(void)
  633. {
  634. av_register_output_format(&mpeg1system_mux);
  635. av_register_output_format(&mpeg1vcd_mux);
  636. av_register_output_format(&mpeg2vob_mux);
  637. av_register_input_format(&mpegps_demux);
  638. return 0;
  639. }