falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
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.
651 Commits
32 Branches
325MB
Tree: 76c0441b10
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '76c0441b10'
${ noResults }
FFmpeg/libav/mpeg.c

895 lines
25KB
Raw Blame History 

  1. /*

  2.  * Output a MPEG1 multiplexed video/audio stream

  3.  * Copyright (c) 2000 Gerard Lantau.

  4.  *

  5.  * This program is free software; you can redistribute it and/or modify

  6.  * it under the terms of the GNU General Public License as published by

  7.  * the Free Software Foundation; either version 2 of the License, or

  8.  * (at your option) any later version.

  9.  *

  10.  * This program 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

  13.  * GNU General Public License for more details.

  14.  *

  15.  * You should have received a copy of the GNU General Public License

  16.  * along with this program; if not, write to the Free Software

  17.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  18.  */

  19. #include "avformat.h"

  20. #include "tick.h"

  21. 

  22. #define MAX_PAYLOAD_SIZE 4096

  23. #define NB_STREAMS 2

  24. 

  25. typedef struct {

  26.     UINT8 buffer[MAX_PAYLOAD_SIZE];

  27.     int buffer_ptr;

  28.     UINT8 id;

  29.     int max_buffer_size; /* in bytes */

  30.     int packet_number;

  31.     INT64 pts;

  32.     Ticker pts_ticker;

  33.     INT64 start_pts;

  34. } StreamInfo;

  35. 

  36. typedef struct {

  37.     int packet_size; /* required packet size */

  38.     int packet_data_max_size; /* maximum data size inside a packet */

  39.     int packet_number;

  40.     int pack_header_freq;     /* frequency (in packets^-1) at which we send pack headers */

  41.     int system_header_freq;

  42.     int mux_rate; /* bitrate in units of 50 bytes/s */

  43.     /* stream info */

  44.     int audio_bound;

  45.     int video_bound;

  46. } MpegMuxContext;

  47. 

  48. #define PACK_START_CODE             ((unsigned int)0x000001ba)

  49. #define SYSTEM_HEADER_START_CODE    ((unsigned int)0x000001bb)

  50. #define SEQUENCE_END_CODE           ((unsigned int)0x000001b7)

  51. #define PACKET_START_CODE_MASK      ((unsigned int)0xffffff00)

  52. #define PACKET_START_CODE_PREFIX    ((unsigned int)0x00000100)

  53. #define ISO_11172_END_CODE          ((unsigned int)0x000001b9)

  54.   

  55. /* mpeg2 */

  56. #define PROGRAM_STREAM_MAP 0x1bc

  57. #define PRIVATE_STREAM_1   0x1bd

  58. #define PADDING_STREAM     0x1be

  59. #define PRIVATE_STREAM_2   0x1bf

  60. 

  61. 

  62. #define AUDIO_ID 0xc0

  63. #define VIDEO_ID 0xe0

  64. 

  65. static int mpeg_mux_check_packet(AVFormatContext *s, int *size);

  66. 

  67. static int put_pack_header(AVFormatContext *ctx, 

  68.                            UINT8 *buf, INT64 timestamp)

  69. {

  70.     MpegMuxContext *s = ctx->priv_data;

  71.     PutBitContext pb;

  72.     

  73.     init_put_bits(&pb, buf, 128, NULL, NULL);

  74. 

  75.     put_bits(&pb, 32, PACK_START_CODE);

  76.     put_bits(&pb, 4, 0x2);

  77.     put_bits(&pb, 3, (UINT32)((timestamp >> 30) & 0x07));

  78.     put_bits(&pb, 1, 1);

  79.     put_bits(&pb, 15, (UINT32)((timestamp >> 15) & 0x7fff));

  80.     put_bits(&pb, 1, 1);

  81.     put_bits(&pb, 15, (UINT32)((timestamp) & 0x7fff));

  82.     put_bits(&pb, 1, 1);

  83.     put_bits(&pb, 1, 1);

  84.     put_bits(&pb, 22, s->mux_rate);

  85.     put_bits(&pb, 1, 1);

  86. 

  87.     flush_put_bits(&pb);

  88.     return pbBufPtr(&pb) - pb.buf;

  89. }

  90. 

  91. static int put_system_header(AVFormatContext *ctx, UINT8 *buf)

  92. {

  93.     MpegMuxContext *s = ctx->priv_data;

  94.     int size, rate_bound, i, private_stream_coded, id;

  95.     PutBitContext pb;

  96. 

  97.     init_put_bits(&pb, buf, 128, NULL, NULL);

  98. 

  99.     put_bits(&pb, 32, SYSTEM_HEADER_START_CODE);

  100.     put_bits(&pb, 16, 0);

  101.     put_bits(&pb, 1, 1);

  102.     

  103.     rate_bound = s->mux_rate; /* maximum bit rate of the multiplexed stream */

  104.     put_bits(&pb, 22, rate_bound);

  105.     put_bits(&pb, 1, 1); /* marker */

  106.     put_bits(&pb, 6, s->audio_bound);

  107. 

  108.     put_bits(&pb, 1, 1); /* variable bitrate */

  109.     put_bits(&pb, 1, 1); /* non constrainted bit stream */

  110.     

  111.     put_bits(&pb, 1, 0); /* audio locked */

  112.     put_bits(&pb, 1, 0); /* video locked */

  113.     put_bits(&pb, 1, 1); /* marker */

  114. 

  115.     put_bits(&pb, 5, s->video_bound);

  116.     put_bits(&pb, 8, 0xff); /* reserved byte */

  117.     

  118.     /* audio stream info */

  119.     private_stream_coded = 0;

  120.     for(i=0;i<ctx->nb_streams;i++) {

  121.         StreamInfo *stream = ctx->streams[i]->priv_data;

  122.         id = stream->id;

  123.         if (id < 0xc0) {

  124.             /* special case for private streams (AC3 use that) */

  125.             if (private_stream_coded)

  126.                 continue;

  127.             private_stream_coded = 1;

  128.             id = 0xbd;

  129.         }

  130.         put_bits(&pb, 8, id); /* stream ID */

  131.         put_bits(&pb, 2, 3);

  132.         if (id < 0xe0) {

  133.             /* audio */

  134.             put_bits(&pb, 1, 0);

  135.             put_bits(&pb, 13, stream->max_buffer_size / 128);

  136.         } else {

  137.             /* video */

  138.             put_bits(&pb, 1, 1);

  139.             put_bits(&pb, 13, stream->max_buffer_size / 1024);

  140.         }

  141.     }

  142.     flush_put_bits(&pb);

  143.     size = pbBufPtr(&pb) - pb.buf;

  144.     /* patch packet size */

  145.     buf[4] = (size - 6) >> 8;

  146.     buf[5] = (size - 6) & 0xff;

  147. 

  148.     return size;

  149. }

  150. 

  151. static int mpeg_mux_init(AVFormatContext *ctx)

  152. {

  153.     MpegMuxContext *s;

  154.     int bitrate, i, mpa_id, mpv_id, ac3_id;

  155.     AVStream *st;

  156.     StreamInfo *stream;

  157. 

  158.     s = malloc(sizeof(MpegMuxContext));

  159.     if (!s)

  160.         return -1;

  161.     memset(s, 0, sizeof(MpegMuxContext));

  162.     ctx->priv_data = s;

  163.     s->packet_number = 0;

  164. 

  165.     /* XXX: hardcoded */

  166.     if (ctx->flags & AVF_FLAG_VCD)

  167.         s->packet_size = 2324; /* VCD packet size */

  168.     else

  169.         s->packet_size = 2048;

  170.         

  171.     /* startcode(4) + length(2) + flags(1) */

  172.     s->packet_data_max_size = s->packet_size - 7;

  173.     s->audio_bound = 0;

  174.     s->video_bound = 0;

  175.     mpa_id = AUDIO_ID;

  176.     ac3_id = 0x80;

  177.     mpv_id = VIDEO_ID;

  178.     for(i=0;i<ctx->nb_streams;i++) {

  179.         st = ctx->streams[i];

  180.         stream = av_mallocz(sizeof(StreamInfo));

  181.         if (!stream)

  182.             goto fail;

  183.         st->priv_data = stream;

  184. 

  185.         switch(st->codec.codec_type) {

  186.         case CODEC_TYPE_AUDIO:

  187.             if (st->codec.codec_id == CODEC_ID_AC3)

  188.                 stream->id = ac3_id++;

  189.             else

  190.                 stream->id = mpa_id++;

  191.             stream->max_buffer_size = 4 * 1024; 

  192.             s->audio_bound++;

  193.             break;

  194.         case CODEC_TYPE_VIDEO:

  195.             stream->id = mpv_id++;

  196.             stream->max_buffer_size = 46 * 1024; 

  197.             s->video_bound++;

  198.             break;

  199.         default:

  200.             abort();

  201.         }

  202.     }

  203. 

  204.     /* we increase slightly the bitrate to take into account the

  205.        headers. XXX: compute it exactly */

  206.     bitrate = 2000;

  207.     for(i=0;i<ctx->nb_streams;i++) {

  208.         st = ctx->streams[i];

  209.         bitrate += st->codec.bit_rate;

  210.     }

  211.     s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);

  212.     

  213.     if (ctx->flags & AVF_FLAG_VCD)

  214.         /* every packet */

  215.         s->pack_header_freq = 1;

  216.     else

  217.         /* every 2 seconds */

  218.         s->pack_header_freq = 2 * bitrate / s->packet_size / 8;

  219.     

  220.     if (ctx->flags & AVF_FLAG_VCD)

  221.         /* every 40 packets, this is my invention */

  222.         s->system_header_freq = s->pack_header_freq * 40;

  223.     else

  224.         /* every 10 seconds */

  225.         s->system_header_freq = s->pack_header_freq * 5;

  226.     

  227.     

  228.     for(i=0;i<ctx->nb_streams;i++) {

  229.         stream = ctx->streams[i]->priv_data;

  230.         stream->buffer_ptr = 0;

  231.         stream->packet_number = 0;

  232.         stream->pts = 0;

  233.         stream->start_pts = -1;

  234. 

  235.         st = ctx->streams[i];

  236.         switch (st->codec.codec_type) {

  237.         case CODEC_TYPE_AUDIO:

  238.             ticker_init(&stream->pts_ticker,

  239.                         st->codec.sample_rate,

  240.                         90000 * st->codec.frame_size);

  241.             break;

  242.         case CODEC_TYPE_VIDEO:

  243.             ticker_init(&stream->pts_ticker,

  244.                         st->codec.frame_rate,

  245.                         90000 * FRAME_RATE_BASE);

  246.             break;

  247.         default:

  248.             abort();

  249.         }

  250.     }

  251.     return 0;

  252.  fail:

  253.     for(i=0;i<ctx->nb_streams;i++) {

  254.         free(ctx->streams[i]->priv_data);

  255.     }

  256.     free(s);

  257.     return -ENOMEM;

  258. }

  259. 

  260. /* flush the packet on stream stream_index */

  261. static void flush_packet(AVFormatContext *ctx, int stream_index, int last_pkt)

  262. {

  263.     MpegMuxContext *s = ctx->priv_data;

  264.     StreamInfo *stream = ctx->streams[stream_index]->priv_data;

  265.     UINT8 *buf_ptr;

  266.     int size, payload_size, startcode, id, len, stuffing_size, i;

  267.     INT64 timestamp;

  268.     UINT8 buffer[128];

  269.     int last = last_pkt ? 4 : 0;

  270.     

  271.     id = stream->id;

  272.     timestamp = stream->start_pts;

  273. 

  274. #if 0

  275.     printf("packet ID=%2x PTS=%0.3f\n", 

  276.            id, timestamp / 90000.0);

  277. #endif

  278. 

  279.     buf_ptr = buffer;

  280.     if (((s->packet_number % s->pack_header_freq) == 0)) {

  281.         /* output pack and systems header if needed */

  282.         size = put_pack_header(ctx, buf_ptr, timestamp);

  283.         buf_ptr += size;

  284.         if ((s->packet_number % s->system_header_freq) == 0) {

  285.             size = put_system_header(ctx, buf_ptr);

  286.             buf_ptr += size;

  287.         }

  288.     }

  289.     size = buf_ptr - buffer;

  290.     put_buffer(&ctx->pb, buffer, size);

  291. 

  292.     /* packet header */

  293.     payload_size = s->packet_size - (size + 6 + 5 + last);

  294.     if (id < 0xc0) {

  295.         startcode = PRIVATE_STREAM_1;

  296.         payload_size -= 4;

  297.     } else {

  298.         startcode = 0x100 + id;

  299.     }

  300.     stuffing_size = payload_size - stream->buffer_ptr;

  301.     if (stuffing_size < 0)

  302.         stuffing_size = 0;

  303. 

  304.     put_be32(&ctx->pb, startcode);

  305. 

  306.     put_be16(&ctx->pb, payload_size + 5);

  307.     /* stuffing */

  308.     for(i=0;i<stuffing_size;i++)

  309.         put_byte(&ctx->pb, 0xff);

  310.     

  311.     /* presentation time stamp */

  312.     put_byte(&ctx->pb, 

  313.              (0x02 << 4) | 

  314.              (((timestamp >> 30) & 0x07) << 1) | 

  315.              1);

  316.     put_be16(&ctx->pb, (UINT16)((((timestamp >> 15) & 0x7fff) << 1) | 1));

  317.     put_be16(&ctx->pb, (UINT16)((((timestamp) & 0x7fff) << 1) | 1));

  318. 

  319.     if (startcode == PRIVATE_STREAM_1) {

  320.         put_byte(&ctx->pb, id);

  321.         if (id >= 0x80 && id <= 0xbf) {

  322.             /* XXX: need to check AC3 spec */

  323.             put_byte(&ctx->pb, 1);

  324.             put_byte(&ctx->pb, 0);

  325.             put_byte(&ctx->pb, 2);

  326.         }

  327.     }

  328. 

  329.     if (last_pkt) {

  330.         put_be32(&ctx->pb, ISO_11172_END_CODE);

  331.     }

  332.     /* output data */

  333.     put_buffer(&ctx->pb, stream->buffer, payload_size - stuffing_size);

  334.     put_flush_packet(&ctx->pb);

  335.     

  336.     /* preserve remaining data */

  337.     len = stream->buffer_ptr - payload_size;

  338.     if (len < 0) 

  339.         len = 0;

  340.     memmove(stream->buffer, stream->buffer + stream->buffer_ptr - len, len);

  341.     stream->buffer_ptr = len;

  342. 

  343.     s->packet_number++;

  344.     stream->packet_number++;

  345.     stream->start_pts = -1;

  346. }

  347. 

  348. static int mpeg_mux_write_packet(AVFormatContext *ctx, int stream_index,

  349.                                  UINT8 *buf, int size, int force_pts)

  350. {

  351.     MpegMuxContext *s = ctx->priv_data;

  352.     AVStream *st = ctx->streams[stream_index];

  353.     StreamInfo *stream = st->priv_data;

  354.     int len;

  355.     

  356.     while (size > 0) {

  357.         /* set pts */

  358.         if (stream->start_pts == -1) {

  359.             if (force_pts)

  360.                 stream->pts = force_pts;

  361.             stream->start_pts = stream->pts;

  362.         }

  363.         len = s->packet_data_max_size - stream->buffer_ptr;

  364.         if (len > size)

  365.             len = size;

  366.         memcpy(stream->buffer + stream->buffer_ptr, buf, len);

  367.         stream->buffer_ptr += len;

  368.         buf += len;

  369.         size -= len;

  370.         while (stream->buffer_ptr >= s->packet_data_max_size) {

  371.             /* output the packet */

  372.             if (stream->start_pts == -1)

  373.                 stream->start_pts = stream->pts;

  374.             flush_packet(ctx, stream_index, 0);

  375.         }

  376.     }

  377. 

  378.     stream->pts += ticker_tick(&stream->pts_ticker, 1);

  379.     //if (st->codec.codec_type == CODEC_TYPE_VIDEO)

  380.     //    fprintf(stderr,"\nVideo PTS: %6lld", stream->pts);

  381.     //else

  382.     //    fprintf(stderr,"\nAudio PTS: %6lld", stream->pts);

  383.     return 0;

  384. }

  385. 

  386. static int mpeg_mux_end(AVFormatContext *ctx)

  387. {

  388.     StreamInfo *stream;

  389.     int i;

  390. 

  391.     /* flush each packet */

  392.     for(i=0;i<ctx->nb_streams;i++) {

  393.         stream = ctx->streams[i]->priv_data;

  394.         if (stream->buffer_ptr > 0) {

  395.             if (i == (ctx->nb_streams - 1)) 

  396.                 flush_packet(ctx, i, 1);

  397.             else

  398.                 flush_packet(ctx, i, 0);

  399.         }

  400.     }

  401. 

  402.     /* write the end header */

  403.     //put_be32(&ctx->pb, ISO_11172_END_CODE);

  404.     //put_flush_packet(&ctx->pb);

  405.     return 0;

  406. }

  407. 

  408. /*********************************************/

  409. /* demux code */

  410. 

  411. #define MAX_SYNC_SIZE 100000

  412. 

  413. typedef struct MpegDemuxContext {

  414.     int header_state;

  415.     int mux_rate; /* 50 byte/s unit */

  416. } MpegDemuxContext;

  417. 

  418. static int find_start_code(ByteIOContext *pb, int *size_ptr, 

  419.                            UINT32 *header_state)

  420. {

  421.     unsigned int state, v;

  422.     int val, n;

  423. 

  424.     state = *header_state;

  425.     n = *size_ptr;

  426.     while (n > 0) {

  427.         if (url_feof(pb))

  428.             break;

  429.         v = get_byte(pb);

  430.         n--;

  431.         if (state == 0x000001) {

  432.             state = ((state << 8) | v) & 0xffffff;

  433.             val = state;

  434.             goto found;

  435.         }

  436.         state = ((state << 8) | v) & 0xffffff;

  437.     }

  438.     val = -1;

  439.  found:

  440.     *header_state = state;

  441.     *size_ptr = n;

  442.     return val;

  443. }

  444. 

  445. static int check_stream_id(AVFormatContext *s, int c_id)

  446. {

  447.     AVStream *st;

  448.     int i;

  449.     

  450.     for(i = 0;i < s->nb_streams;i++) {

  451.         st = s->streams[i];

  452.         if (st && st->id == c_id)

  453.             return 1;

  454.     }

  455.     return 0;   

  456. }

  457. 

  458. static int mpeg_mux_read_header(AVFormatContext *s,

  459.                                 AVFormatParameters *ap)

  460. {

  461.     MpegDemuxContext *m;

  462.     int size, startcode, c, rate_bound, audio_bound, video_bound, mux_rate, val;

  463.     int codec_id, n, i, type, seems_dvd;

  464.     AVStream *st;

  465.     offset_t start_pos;

  466. 

  467.     m = av_mallocz(sizeof(MpegDemuxContext));

  468.     if (!m)

  469.         return -ENOMEM;

  470.     s->priv_data = m;

  471.     seems_dvd = 0;

  472.     

  473.     /* search first pack header */

  474.     m->header_state = 0xff;

  475.     size = MAX_SYNC_SIZE;

  476.     start_pos = url_ftell(&s->pb); /* remember this pos */

  477.     for(;;) {

  478.         /*while (size > 0) {

  479.             startcode = find_start_code(&s->pb, &size, &m->header_state);

  480.             if (startcode == PACK_START_CODE)

  481.                 goto found;

  482.         }*/

  483.         /* System Header not found find streams searching through file */

  484.         //fprintf(stderr,"libav: MPEG-PS System Header not found!\n");

  485.         url_fseek(&s->pb, start_pos, SEEK_SET);

  486.         video_bound = 0;

  487.         audio_bound = 0;

  488.         c = 0;

  489.         s->nb_streams = 0;

  490.         //size = 15*MAX_SYNC_SIZE;

  491.         while (size > 0) {

  492.             type = 0;

  493.             codec_id = 0;

  494.             n = 0;

  495.             startcode = find_start_code(&s->pb, &size, &m->header_state);

  496.             //fprintf(stderr,"\nstartcode: %x pos=0x%Lx\n", startcode, url_ftell(&s->pb));

  497.             if (startcode == 0x1bd) {

  498.                 url_fseek(&s->pb, -4, SEEK_CUR);

  499.                 size += 4;

  500.                 startcode = mpeg_mux_check_packet(s, &size);

  501.                 //fprintf(stderr,"\nstartcode: %x pos=0x%Lx\n", startcode, url_ftell(&s->pb));

  502.                 if (startcode >= 0x80 && startcode <= 0x9f && !check_stream_id(s, startcode)) {

  503.                     //fprintf(stderr,"Found AC3 stream ID: 0x%x\n", startcode);

  504.                     type = CODEC_TYPE_AUDIO;

  505.                     codec_id = CODEC_ID_AC3;

  506.                     audio_bound++;

  507.                     n = 1;

  508.                     c = startcode;

  509.                     seems_dvd = 1;

  510.                 }    

  511.             } else if (startcode == 0x1e0 && !check_stream_id(s, startcode)) {

  512.                 //fprintf(stderr,"Found MPEGVIDEO stream ID: 0x%x\n", startcode);

  513.                 type = CODEC_TYPE_VIDEO;

  514.                 codec_id = CODEC_ID_MPEG1VIDEO;

  515.                 n = 1;

  516.                 c = startcode;

  517.                 video_bound++;

  518.             } else if (startcode >= 0x1c0 && startcode <= 0x1df && !seems_dvd && !check_stream_id(s, startcode)) {

  519.                 //fprintf(stderr,"Found MPEGAUDIO stream ID: 0x%x\n", startcode);

  520.                 type = CODEC_TYPE_AUDIO;

  521.                 codec_id = CODEC_ID_MP2;

  522.                 n = 1;

  523.                 c = startcode;

  524.                 audio_bound++;

  525.             } 

  526.             for(i=0;i<n;i++) {

  527.                 st = av_mallocz(sizeof(AVStream));

  528.                 if (!st)

  529.                     return -ENOMEM;

  530.                 s->streams[s->nb_streams++] = st;

  531.                 st->id = c;

  532.                 st->codec.codec_type = type;

  533.                 st->codec.codec_id = codec_id;

  534.             }

  535.         }

  536.         if (video_bound || audio_bound) {

  537.             url_fseek(&s->pb, start_pos, SEEK_SET);

  538.             return 0;

  539.         } else

  540.             return -ENODATA;

  541.     found:

  542.         /* search system header just after pack header */

  543.         /* parse pack header */

  544.         get_byte(&s->pb); /* ts1 */

  545.         get_be16(&s->pb); /* ts2 */

  546.         get_be16(&s->pb); /* ts3 */

  547. 

  548.         mux_rate = get_byte(&s->pb) << 16; 

  549.         mux_rate |= get_byte(&s->pb) << 8;

  550.         mux_rate |= get_byte(&s->pb);

  551.         mux_rate &= (1 << 22) - 1;

  552.         m->mux_rate = mux_rate;

  553. 

  554.         startcode = find_start_code(&s->pb, &size, &m->header_state);

  555.         if (startcode == SYSTEM_HEADER_START_CODE)

  556.             break;

  557.     }

  558.     size = get_be16(&s->pb);

  559.     rate_bound = get_byte(&s->pb) << 16;

  560.     rate_bound |= get_byte(&s->pb) << 8;

  561.     rate_bound |= get_byte(&s->pb);

  562.     rate_bound = (rate_bound >> 1) & ((1 << 22) - 1);

  563.     audio_bound = get_byte(&s->pb) >> 2;

  564.     video_bound = get_byte(&s->pb) & 0x1f;

  565.     get_byte(&s->pb); /* reserved byte */

  566. #if 0

  567.     printf("mux_rate=%d kbit/s\n", (m->mux_rate * 50 * 8) / 1000);

  568.     printf("rate_bound=%d\n", rate_bound);

  569.     printf("audio_bound=%d\n", audio_bound);

  570.     printf("video_bound=%d\n", video_bound);

  571. #endif

  572.     size -= 6;

  573.     s->nb_streams = 0;

  574.     while (size > 0) {

  575.         c = get_byte(&s->pb);

  576.         size--;

  577.         if ((c & 0x80) == 0)

  578.             break;

  579.         val = get_be16(&s->pb);

  580.         size -= 2;

  581.         if (c >= 0xc0 && c <= 0xdf) {

  582.             /* mpeg audio stream */

  583.             type = CODEC_TYPE_AUDIO;

  584.             codec_id = CODEC_ID_MP2;

  585.             n = 1;

  586.             c = c | 0x100;

  587.         } else if (c >= 0xe0 && c <= 0xef) {

  588.             type = CODEC_TYPE_VIDEO;

  589.             codec_id = CODEC_ID_MPEG1VIDEO;

  590.             n = 1;

  591.             c = c | 0x100;

  592.         } else if (c == 0xb8) {

  593.             /* all audio streams */

  594.             /* XXX: hack for DVD: we force AC3, although we do not

  595.                know that this codec will be used */

  596.             type = CODEC_TYPE_AUDIO;

  597.             codec_id = CODEC_ID_AC3;

  598.             /* XXX: Another hack for DVD: it seems, that AC3 streams

  599.                aren't signaled on audio_bound on some DVDs (Matrix) */

  600.             if (audio_bound == 0)

  601.             	audio_bound++;

  602.             n = audio_bound;

  603.             c = 0x80;

  604.             //c = 0x1c0;

  605.         } else if (c == 0xb9) {

  606.             /* all video streams */

  607.             type = CODEC_TYPE_VIDEO;

  608.             codec_id = CODEC_ID_MPEG1VIDEO;

  609.             n = video_bound;

  610.             c = 0x1e0;

  611.         } else {

  612.             type = 0;

  613.             codec_id = 0;

  614.             n = 0;

  615.         }

  616.         for(i=0;i<n;i++) {

  617.             st = av_mallocz(sizeof(AVStream));

  618.             if (!st)

  619.                 return -ENOMEM;

  620.             s->streams[s->nb_streams++] = st;

  621.             st->id = c + i;

  622.             st->codec.codec_type = type;

  623.             st->codec.codec_id = codec_id;

  624.         }

  625.     }

  626. 

  627.     return 0;

  628. }

  629. 

  630. static INT64 get_pts(ByteIOContext *pb, int c)

  631. {

  632.     INT64 pts;

  633.     int val;

  634. 

  635.     if (c < 0)

  636.         c = get_byte(pb);

  637.     pts = (INT64)((c >> 1) & 0x07) << 30;

  638.     val = get_be16(pb);

  639.     pts |= (INT64)(val >> 1) << 15;

  640.     val = get_be16(pb);

  641.     pts |= (INT64)(val >> 1);

  642.     return pts;

  643. }

  644. 

  645. static int mpeg_mux_read_packet(AVFormatContext *s,

  646.                                 AVPacket *pkt)

  647. {

  648.     MpegDemuxContext *m = s->priv_data;

  649.     AVStream *st;

  650.     int len, size, startcode, i, c, flags, header_len;

  651.     INT64 pts, dts;

  652. 

  653.     /* next start code (should be immediately after */

  654.  redo:

  655.     m->header_state = 0xff;

  656.     size = MAX_SYNC_SIZE;

  657.     startcode = find_start_code(&s->pb, &size, &m->header_state);

  658.     //printf("startcode=%x pos=0x%Lx\n", startcode, url_ftell(&s->pb));

  659.     if (startcode < 0)

  660.         return -EIO;

  661.     if (startcode == PACK_START_CODE)

  662.         goto redo;

  663.     if (startcode == SYSTEM_HEADER_START_CODE)

  664.         goto redo;

  665.     if (startcode == PADDING_STREAM ||

  666.         startcode == PRIVATE_STREAM_2) {

  667.         /* skip them */

  668.         len = get_be16(&s->pb);

  669.         url_fskip(&s->pb, len);

  670.         goto redo;

  671.     }

  672.     /* find matching stream */

  673.     if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||

  674.           (startcode >= 0x1e0 && startcode <= 0x1ef) ||

  675.           (startcode == 0x1bd)))

  676.         goto redo;

  677. 

  678.     len = get_be16(&s->pb);

  679.     pts = 0;

  680.     dts = 0;

  681.     /* stuffing */

  682.     for(;;) {

  683.         c = get_byte(&s->pb);

  684.         len--;

  685.         /* XXX: for mpeg1, should test only bit 7 */

  686.         if (c != 0xff) 

  687.             break;

  688.     }

  689.     if ((c & 0xc0) == 0x40) {

  690.         /* buffer scale & size */

  691.         get_byte(&s->pb);

  692.         c = get_byte(&s->pb);

  693.         len -= 2;

  694.     }

  695.     if ((c & 0xf0) == 0x20) {

  696.         pts = get_pts(&s->pb, c);

  697.         len -= 4;

  698.         dts = pts;

  699.     } else if ((c & 0xf0) == 0x30) {

  700.         pts = get_pts(&s->pb, c);

  701.         dts = get_pts(&s->pb, -1);

  702.         len -= 9;

  703.     } else if ((c & 0xc0) == 0x80) {

  704.         /* mpeg 2 PES */

  705.         if ((c & 0x30) != 0) {

  706.             fprintf(stderr, "Encrypted multiplex not handled\n");

  707.             return -EIO;

  708.         }

  709.         flags = get_byte(&s->pb);

  710.         header_len = get_byte(&s->pb);

  711.         len -= 2;

  712.         if (header_len > len)

  713.             goto redo;

  714.         if ((flags & 0xc0) == 0x40) {

  715.             pts = get_pts(&s->pb, -1);

  716.             dts = pts;

  717.             header_len -= 5;

  718.             len -= 5;

  719.         } if ((flags & 0xc0) == 0xc0) {

  720.             pts = get_pts(&s->pb, -1);

  721.             dts = get_pts(&s->pb, -1);

  722.             header_len -= 10;

  723.             len -= 10;

  724.         }

  725.         len -= header_len;

  726.         while (header_len > 0) {

  727.             get_byte(&s->pb);

  728.             header_len--;

  729.         }

  730.     }

  731.     if (startcode == 0x1bd) {

  732.         startcode = get_byte(&s->pb);

  733.         len--;

  734.         if (startcode >= 0x80 && startcode <= 0xbf) {

  735.             /* audio: skip header */

  736.             get_byte(&s->pb);

  737.             get_byte(&s->pb);

  738.             get_byte(&s->pb);

  739.             len -= 3;

  740.         }

  741.     }

  742. 

  743.     /* now find stream */

  744.     for(i=0;i<s->nb_streams;i++) {

  745.         st = s->streams[i];

  746.         if (st->id == startcode)

  747.             goto found;

  748.     }

  749.     /* skip packet */

  750.     url_fskip(&s->pb, len);

  751.     goto redo;

  752.  found:

  753.     av_new_packet(pkt, len);

  754.     //printf("\nRead Packet ID: %x PTS: %f Size: %d", startcode,

  755.     //       (float)pts/90000, len);

  756.     get_buffer(&s->pb, pkt->data, pkt->size);

  757.     pkt->pts = pts;

  758.     pkt->stream_index = i;

  759.     return 0;

  760. }

  761. 

  762. static int mpeg_mux_check_packet(AVFormatContext *s, int *size)

  763. {

  764.     MpegDemuxContext *m = s->priv_data;

  765.     int len, startcode, c, n, flags, header_len;

  766.     INT64 pts, dts;

  767. 

  768.     /* next start code (should be immediately after */

  769.  redo:

  770.     m->header_state = 0xff;

  771.     startcode = find_start_code(&s->pb, size, &m->header_state);

  772.     

  773.     if (startcode < 0)

  774.         return -EIO;

  775.     if (startcode == PACK_START_CODE)

  776.         goto redo;

  777.     if (startcode == SYSTEM_HEADER_START_CODE)

  778.         goto redo;

  779.     if (startcode == PADDING_STREAM ||

  780.         startcode == PRIVATE_STREAM_2) {

  781.         /* skip them */

  782.         len = get_be16(&s->pb);

  783.         url_fskip(&s->pb, len);

  784.         goto redo;

  785.     }

  786.     /* find matching stream */

  787.     if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||

  788.           (startcode >= 0x1e0 && startcode <= 0x1ef) ||

  789.           (startcode == 0x1bd)))

  790.         goto redo;

  791. 

  792.     n = *size;

  793.     len = get_be16(&s->pb);

  794.     n -= 2;

  795.     pts = 0;

  796.     dts = 0;

  797.     /* stuffing */

  798.     for(;;) {

  799.         c = get_byte(&s->pb);

  800.         len--;

  801.         n--;

  802.         /* XXX: for mpeg1, should test only bit 7 */

  803.         if (c != 0xff) 

  804.             break;

  805.     }

  806.     if ((c & 0xc0) == 0x40) {

  807.         /* buffer scale & size */

  808.         get_byte(&s->pb);

  809.         c = get_byte(&s->pb);

  810.         len -= 2;

  811.         n -= 2;

  812.     }

  813.     if ((c & 0xf0) == 0x20) {

  814.         pts = get_pts(&s->pb, c);

  815.         len -= 4;

  816.         n -= 4;

  817.         dts = pts;

  818.     } else if ((c & 0xf0) == 0x30) {

  819.         pts = get_pts(&s->pb, c);

  820.         dts = get_pts(&s->pb, -1);

  821.         len -= 9;

  822.         n -= 9;

  823.     } else if ((c & 0xc0) == 0x80) {

  824.         /* mpeg 2 PES */

  825.         if ((c & 0x30) != 0) {

  826.             fprintf(stderr, "Encrypted multiplex not handled\n");

  827.             return -EIO;

  828.         }

  829.         flags = get_byte(&s->pb);

  830.         header_len = get_byte(&s->pb);

  831.         len -= 2;

  832.         n -= 2;

  833.         if (header_len > len)

  834.             goto redo;

  835.         if ((flags & 0xc0) == 0x40) {

  836.             pts = get_pts(&s->pb, -1);

  837.             dts = pts;

  838.             header_len -= 5;

  839.             len -= 5;

  840.             n -= 5;

  841.         } if ((flags & 0xc0) == 0xc0) {

  842.             pts = get_pts(&s->pb, -1);

  843.             dts = get_pts(&s->pb, -1);

  844.             header_len -= 10;

  845.             len -= 10;

  846.             n -= 10;

  847.         }

  848.         len -= header_len;

  849.         n -= header_len;

  850.         while (header_len > 0) {

  851.             get_byte(&s->pb);

  852.             header_len--;

  853.         }

  854.     }

  855.     if (startcode == 0x1bd) {

  856.         startcode = get_byte(&s->pb);

  857.         len--;

  858.         n--;

  859.         if (startcode >= 0x80 && startcode <= 0xbf) {

  860.             /* audio: skip header */

  861.             get_byte(&s->pb);

  862.             get_byte(&s->pb);

  863.             get_byte(&s->pb);

  864.             len -= 3;

  865.             n -= 3;

  866.         }

  867.     }

  868.     *size = n;

  869.     return startcode;

  870. }

  871. 

  872. 

  873. static int mpeg_mux_read_close(AVFormatContext *s)

  874. {

  875.     MpegDemuxContext *m = s->priv_data;

  876.     free(m);

  877.     return 0;

  878. }

  879. 

  880. AVFormat mpeg_mux_format = {

  881.     "mpeg",

  882.     "MPEG multiplex format",

  883.     "video/x-mpeg",

  884.     "mpg,mpeg,vob",

  885.     CODEC_ID_MP2,

  886.     CODEC_ID_MPEG1VIDEO,

  887.     mpeg_mux_init,

  888.     mpeg_mux_write_packet,

  889.     mpeg_mux_end,

  890. 

  891.     mpeg_mux_read_header,

  892.     mpeg_mux_read_packet,

  893.     mpeg_mux_read_close,

  894. };