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.
648 Commits
32 Branches
5.3GB
Tree: e8f147930b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e8f147930b'
${ noResults }
FFmpeg/libav/mpeg.c

891 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.     return 0;

  380. }

  381. 

  382. static int mpeg_mux_end(AVFormatContext *ctx)

  383. {

  384.     StreamInfo *stream;

  385.     int i;

  386. 

  387.     /* flush each packet */

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

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

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

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

  392.                 flush_packet(ctx, i, 1);

  393.             else

  394.                 flush_packet(ctx, i, 0);

  395.         }

  396.     }

  397. 

  398.     /* write the end header */

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

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

  401.     return 0;

  402. }

  403. 

  404. /*********************************************/

  405. /* demux code */

  406. 

  407. #define MAX_SYNC_SIZE 100000

  408. 

  409. typedef struct MpegDemuxContext {

  410.     int header_state;

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

  412. } MpegDemuxContext;

  413. 

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

  415.                            UINT32 *header_state)

  416. {

  417.     unsigned int state, v;

  418.     int val, n;

  419. 

  420.     state = *header_state;

  421.     n = *size_ptr;

  422.     while (n > 0) {

  423.         if (url_feof(pb))

  424.             break;

  425.         v = get_byte(pb);

  426.         n--;

  427.         if (state == 0x000001) {

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

  429.             val = state;

  430.             goto found;

  431.         }

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

  433.     }

  434.     val = -1;

  435.  found:

  436.     *header_state = state;

  437.     *size_ptr = n;

  438.     return val;

  439. }

  440. 

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

  442. {

  443.     AVStream *st;

  444.     int i;

  445.     

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

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

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

  449.             return 1;

  450.     }

  451.     return 0;   

  452. }

  453. 

  454. static int mpeg_mux_read_header(AVFormatContext *s,

  455.                                 AVFormatParameters *ap)

  456. {

  457.     MpegDemuxContext *m;

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

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

  460.     AVStream *st;

  461.     offset_t start_pos;

  462. 

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

  464.     if (!m)

  465.         return -ENOMEM;

  466.     s->priv_data = m;

  467.     seems_dvd = 0;

  468.     

  469.     /* search first pack header */

  470.     m->header_state = 0xff;

  471.     size = MAX_SYNC_SIZE;

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

  473.     for(;;) {

  474.         /*while (size > 0) {

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

  476.             if (startcode == PACK_START_CODE)

  477.                 goto found;

  478.         }*/

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

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

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

  482.         video_bound = 0;

  483.         audio_bound = 0;

  484.         c = 0;

  485.         s->nb_streams = 0;

  486.         //size = 15*MAX_SYNC_SIZE;

  487.         while (size > 0) {

  488.             type = 0;

  489.             codec_id = 0;

  490.             n = 0;

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

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

  493.             if (startcode == 0x1bd) {

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

  495.                 size += 4;

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

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

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

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

  500.                     type = CODEC_TYPE_AUDIO;

  501.                     codec_id = CODEC_ID_AC3;

  502.                     audio_bound++;

  503.                     n = 1;

  504.                     c = startcode;

  505.                     seems_dvd = 1;

  506.                 }    

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

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

  509.                 type = CODEC_TYPE_VIDEO;

  510.                 codec_id = CODEC_ID_MPEG1VIDEO;

  511.                 n = 1;

  512.                 c = startcode;

  513.                 video_bound++;

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

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

  516.                 type = CODEC_TYPE_AUDIO;

  517.                 codec_id = CODEC_ID_MP2;

  518.                 n = 1;

  519.                 c = startcode;

  520.                 audio_bound++;

  521.             } 

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

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

  524.                 if (!st)

  525.                     return -ENOMEM;

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

  527.                 st->id = c;

  528.                 st->codec.codec_type = type;

  529.                 st->codec.codec_id = codec_id;

  530.             }

  531.         }

  532.         if (video_bound || audio_bound) {

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

  534.             return 0;

  535.         } else

  536.             return -ENODATA;

  537.     found:

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

  539.         /* parse pack header */

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

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

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

  543. 

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

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

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

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

  548.         m->mux_rate = mux_rate;

  549. 

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

  551.         if (startcode == SYSTEM_HEADER_START_CODE)

  552.             break;

  553.     }

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

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

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

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

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

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

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

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

  562. #if 0

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

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

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

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

  567. #endif

  568.     size -= 6;

  569.     s->nb_streams = 0;

  570.     while (size > 0) {

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

  572.         size--;

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

  574.             break;

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

  576.         size -= 2;

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

  578.             /* mpeg audio stream */

  579.             type = CODEC_TYPE_AUDIO;

  580.             codec_id = CODEC_ID_MP2;

  581.             n = 1;

  582.             c = c | 0x100;

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

  584.             type = CODEC_TYPE_VIDEO;

  585.             codec_id = CODEC_ID_MPEG1VIDEO;

  586.             n = 1;

  587.             c = c | 0x100;

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

  589.             /* all audio streams */

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

  591.                know that this codec will be used */

  592.             type = CODEC_TYPE_AUDIO;

  593.             codec_id = CODEC_ID_AC3;

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

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

  596.             if (audio_bound == 0)

  597.             	audio_bound++;

  598.             n = audio_bound;

  599.             c = 0x80;

  600.             //c = 0x1c0;

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

  602.             /* all video streams */

  603.             type = CODEC_TYPE_VIDEO;

  604.             codec_id = CODEC_ID_MPEG1VIDEO;

  605.             n = video_bound;

  606.             c = 0x1e0;

  607.         } else {

  608.             type = 0;

  609.             codec_id = 0;

  610.             n = 0;

  611.         }

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

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

  614.             if (!st)

  615.                 return -ENOMEM;

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

  617.             st->id = c + i;

  618.             st->codec.codec_type = type;

  619.             st->codec.codec_id = codec_id;

  620.         }

  621.     }

  622. 

  623.     return 0;

  624. }

  625. 

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

  627. {

  628.     INT64 pts;

  629.     int val;

  630. 

  631.     if (c < 0)

  632.         c = get_byte(pb);

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

  634.     val = get_be16(pb);

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

  636.     val = get_be16(pb);

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

  638.     return pts;

  639. }

  640. 

  641. static int mpeg_mux_read_packet(AVFormatContext *s,

  642.                                 AVPacket *pkt)

  643. {

  644.     MpegDemuxContext *m = s->priv_data;

  645.     AVStream *st;

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

  647.     INT64 pts, dts;

  648. 

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

  650.  redo:

  651.     m->header_state = 0xff;

  652.     size = MAX_SYNC_SIZE;

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

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

  655.     if (startcode < 0)

  656.         return -EIO;

  657.     if (startcode == PACK_START_CODE)

  658.         goto redo;

  659.     if (startcode == SYSTEM_HEADER_START_CODE)

  660.         goto redo;

  661.     if (startcode == PADDING_STREAM ||

  662.         startcode == PRIVATE_STREAM_2) {

  663.         /* skip them */

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

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

  666.         goto redo;

  667.     }

  668.     /* find matching stream */

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

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

  671.           (startcode == 0x1bd)))

  672.         goto redo;

  673. 

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

  675.     pts = 0;

  676.     dts = 0;

  677.     /* stuffing */

  678.     for(;;) {

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

  680.         len--;

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

  682.         if (c != 0xff) 

  683.             break;

  684.     }

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

  686.         /* buffer scale & size */

  687.         get_byte(&s->pb);

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

  689.         len -= 2;

  690.     }

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

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

  693.         len -= 4;

  694.         dts = pts;

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

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

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

  698.         len -= 9;

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

  700.         /* mpeg 2 PES */

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

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

  703.             return -EIO;

  704.         }

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

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

  707.         len -= 2;

  708.         if (header_len > len)

  709.             goto redo;

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

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

  712.             dts = pts;

  713.             header_len -= 5;

  714.             len -= 5;

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

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

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

  718.             header_len -= 10;

  719.             len -= 10;

  720.         }

  721.         len -= header_len;

  722.         while (header_len > 0) {

  723.             get_byte(&s->pb);

  724.             header_len--;

  725.         }

  726.     }

  727.     if (startcode == 0x1bd) {

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

  729.         len--;

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

  731.             /* audio: skip header */

  732.             get_byte(&s->pb);

  733.             get_byte(&s->pb);

  734.             get_byte(&s->pb);

  735.             len -= 3;

  736.         }

  737.     }

  738. 

  739.     /* now find stream */

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

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

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

  743.             goto found;

  744.     }

  745.     /* skip packet */

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

  747.     goto redo;

  748.  found:

  749.     av_new_packet(pkt, len);

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

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

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

  753.     pkt->pts = pts;

  754.     pkt->stream_index = i;

  755.     return 0;

  756. }

  757. 

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

  759. {

  760.     MpegDemuxContext *m = s->priv_data;

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

  762.     INT64 pts, dts;

  763. 

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

  765.  redo:

  766.     m->header_state = 0xff;

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

  768.     

  769.     if (startcode < 0)

  770.         return -EIO;

  771.     if (startcode == PACK_START_CODE)

  772.         goto redo;

  773.     if (startcode == SYSTEM_HEADER_START_CODE)

  774.         goto redo;

  775.     if (startcode == PADDING_STREAM ||

  776.         startcode == PRIVATE_STREAM_2) {

  777.         /* skip them */

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

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

  780.         goto redo;

  781.     }

  782.     /* find matching stream */

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

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

  785.           (startcode == 0x1bd)))

  786.         goto redo;

  787. 

  788.     n = *size;

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

  790.     n -= 2;

  791.     pts = 0;

  792.     dts = 0;

  793.     /* stuffing */

  794.     for(;;) {

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

  796.         len--;

  797.         n--;

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

  799.         if (c != 0xff) 

  800.             break;

  801.     }

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

  803.         /* buffer scale & size */

  804.         get_byte(&s->pb);

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

  806.         len -= 2;

  807.         n -= 2;

  808.     }

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

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

  811.         len -= 4;

  812.         n -= 4;

  813.         dts = pts;

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

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

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

  817.         len -= 9;

  818.         n -= 9;

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

  820.         /* mpeg 2 PES */

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

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

  823.             return -EIO;

  824.         }

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

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

  827.         len -= 2;

  828.         n -= 2;

  829.         if (header_len > len)

  830.             goto redo;

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

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

  833.             dts = pts;

  834.             header_len -= 5;

  835.             len -= 5;

  836.             n -= 5;

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

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

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

  840.             header_len -= 10;

  841.             len -= 10;

  842.             n -= 10;

  843.         }

  844.         len -= header_len;

  845.         n -= header_len;

  846.         while (header_len > 0) {

  847.             get_byte(&s->pb);

  848.             header_len--;

  849.         }

  850.     }

  851.     if (startcode == 0x1bd) {

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

  853.         len--;

  854.         n--;

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

  856.             /* audio: skip header */

  857.             get_byte(&s->pb);

  858.             get_byte(&s->pb);

  859.             get_byte(&s->pb);

  860.             len -= 3;

  861.             n -= 3;

  862.         }

  863.     }

  864.     *size = n;

  865.     return startcode;

  866. }

  867. 

  868. 

  869. static int mpeg_mux_read_close(AVFormatContext *s)

  870. {

  871.     MpegDemuxContext *m = s->priv_data;

  872.     free(m);

  873.     return 0;

  874. }

  875. 

  876. AVFormat mpeg_mux_format = {

  877.     "mpeg",

  878.     "MPEG multiplex format",

  879.     "video/x-mpeg",

  880.     "mpg,mpeg,vob",

  881.     CODEC_ID_MP2,

  882.     CODEC_ID_MPEG1VIDEO,

  883.     mpeg_mux_init,

  884.     mpeg_mux_write_packet,

  885.     mpeg_mux_end,

  886. 

  887.     mpeg_mux_read_header,

  888.     mpeg_mux_read_packet,

  889.     mpeg_mux_read_close,

  890. };