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

865 lines
24KB
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 PACKET_START_CODE_MASK      ((unsigned int)0xffffff00)

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

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

  53.   

  54. /* mpeg2 */

  55. #define PROGRAM_STREAM_MAP 0x1bc

  56. #define PRIVATE_STREAM_1   0x1bd

  57. #define PADDING_STREAM     0x1be

  58. #define PRIVATE_STREAM_2   0x1bf

  59. 

  60. 

  61. #define AUDIO_ID 0xc0

  62. #define VIDEO_ID 0xe0

  63. 

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

  65. 

  66. static int put_pack_header(AVFormatContext *ctx, 

  67.                            UINT8 *buf, INT64 timestamp)

  68. {

  69.     MpegMuxContext *s = ctx->priv_data;

  70.     PutBitContext pb;

  71.     

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

  73. 

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

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

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

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

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

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

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

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

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

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

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

  85. 

  86.     flush_put_bits(&pb);

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

  88. }

  89. 

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

  91. {

  92.     MpegMuxContext *s = ctx->priv_data;

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

  94.     PutBitContext pb;

  95. 

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

  97. 

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

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

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

  101.     

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

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

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

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

  106. 

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

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

  109.     

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

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

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

  113. 

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

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

  116.     

  117.     /* audio stream info */

  118.     private_stream_coded = 0;

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

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

  121.         id = stream->id;

  122.         if (id < 0xc0) {

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

  124.             if (private_stream_coded)

  125.                 continue;

  126.             private_stream_coded = 1;

  127.             id = 0xbd;

  128.         }

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

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

  131.         if (id < 0xe0) {

  132.             /* audio */

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

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

  135.         } else {

  136.             /* video */

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

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

  139.         }

  140.     }

  141.     flush_put_bits(&pb);

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

  143.     /* patch packet size */

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

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

  146. 

  147.     return size;

  148. }

  149. 

  150. static int mpeg_mux_init(AVFormatContext *ctx)

  151. {

  152.     MpegMuxContext *s;

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

  154.     AVStream *st;

  155.     StreamInfo *stream;

  156. 

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

  158.     if (!s)

  159.         return -1;

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

  161.     ctx->priv_data = s;

  162.     s->packet_number = 0;

  163. 

  164.     /* XXX: hardcoded */

  165.     s->packet_size = 2048;

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

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

  168.     s->audio_bound = 0;

  169.     s->video_bound = 0;

  170.     mpa_id = AUDIO_ID;

  171.     ac3_id = 0x80;

  172.     mpv_id = VIDEO_ID;

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

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

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

  176.         if (!stream)

  177.             goto fail;

  178.         st->priv_data = stream;

  179. 

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

  181.         case CODEC_TYPE_AUDIO:

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

  183.                 stream->id = ac3_id++;

  184.             else

  185.                 stream->id = mpa_id++;

  186.             stream->max_buffer_size = 4 * 1024; 

  187.             s->audio_bound++;

  188.             break;

  189.         case CODEC_TYPE_VIDEO:

  190.             stream->id = mpv_id++;

  191.             stream->max_buffer_size = 46 * 1024; 

  192.             s->video_bound++;

  193.             break;

  194.         default:

  195.             abort();

  196.         }

  197.     }

  198. 

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

  200.        headers. XXX: compute it exactly */

  201.     bitrate = 2000;

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

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

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

  205.     }

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

  207.     /* every 2 seconds */

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

  209.     /* every 10 seconds */

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

  211. 

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

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

  214.         stream->buffer_ptr = 0;

  215.         stream->packet_number = 0;

  216.         stream->pts = 0;

  217.         stream->start_pts = -1;

  218. 

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

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

  221.         case CODEC_TYPE_AUDIO:

  222.             ticker_init(&stream->pts_ticker,

  223.                         st->codec.sample_rate,

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

  225.             break;

  226.         case CODEC_TYPE_VIDEO:

  227.             ticker_init(&stream->pts_ticker,

  228.                         st->codec.frame_rate,

  229.                         90000 * FRAME_RATE_BASE);

  230.             break;

  231.         default:

  232.             abort();

  233.         }

  234.     }

  235.     return 0;

  236.  fail:

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

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

  239.     }

  240.     free(s);

  241.     return -ENOMEM;

  242. }

  243. 

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

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

  246. {

  247.     MpegMuxContext *s = ctx->priv_data;

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

  249.     UINT8 *buf_ptr;

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

  251.     INT64 timestamp;

  252.     UINT8 buffer[128];

  253. 

  254.     id = stream->id;

  255.     timestamp = stream->start_pts;

  256. 

  257. #if 0

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

  259.            id, timestamp / 90000.0);

  260. #endif

  261. 

  262.     buf_ptr = buffer;

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

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

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

  266.         buf_ptr += size;

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

  268.             size = put_system_header(ctx, buf_ptr);

  269.             buf_ptr += size;

  270.         }

  271.     }

  272.     size = buf_ptr - buffer;

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

  274. 

  275.     /* packet header */

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

  277.     if (id < 0xc0) {

  278.         startcode = PRIVATE_STREAM_1;

  279.         payload_size -= 4;

  280.     } else {

  281.         startcode = 0x100 + id;

  282.     }

  283.     stuffing_size = payload_size - stream->buffer_ptr;

  284.     if (stuffing_size < 0)

  285.         stuffing_size = 0;

  286. 

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

  288. 

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

  290.     /* stuffing */

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

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

  293.     

  294.     /* presentation time stamp */

  295.     put_byte(&ctx->pb, 

  296.              (0x02 << 4) | 

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

  298.              1);

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

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

  301. 

  302.     if (startcode == PRIVATE_STREAM_1) {

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

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

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

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

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

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

  309.         }

  310.     }

  311. 

  312.     /* output data */

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

  314.     put_flush_packet(&ctx->pb);

  315.     

  316.     /* preserve remaining data */

  317.     len = stream->buffer_ptr - payload_size;

  318.     if (len < 0) 

  319.         len = 0;

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

  321.     stream->buffer_ptr = len;

  322. 

  323.     s->packet_number++;

  324.     stream->packet_number++;

  325.     stream->start_pts = -1;

  326. }

  327. 

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

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

  330. {

  331.     MpegMuxContext *s = ctx->priv_data;

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

  333.     StreamInfo *stream = st->priv_data;

  334.     int len;

  335.     

  336.     while (size > 0) {

  337.         /* set pts */

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

  339.             if (force_pts)

  340.                 stream->pts = force_pts;

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

  342.         }

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

  344.         if (len > size)

  345.             len = size;

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

  347.         stream->buffer_ptr += len;

  348.         buf += len;

  349.         size -= len;

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

  351.             /* output the packet */

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

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

  354.             flush_packet(ctx, stream_index);

  355.         }

  356.     }

  357. 

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

  359.     return 0;

  360. }

  361. 

  362. static int mpeg_mux_end(AVFormatContext *ctx)

  363. {

  364.     StreamInfo *stream;

  365.     int i;

  366. 

  367.     /* flush each packet */

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

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

  370.         if (stream->buffer_ptr > 0) 

  371.             flush_packet(ctx, i);

  372.     }

  373. 

  374.     /* write the end header */

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

  376.     put_flush_packet(&ctx->pb);

  377.     return 0;

  378. }

  379. 

  380. /*********************************************/

  381. /* demux code */

  382. 

  383. #define MAX_SYNC_SIZE 100000

  384. 

  385. typedef struct MpegDemuxContext {

  386.     int header_state;

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

  388. } MpegDemuxContext;

  389. 

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

  391.                            UINT32 *header_state)

  392. {

  393.     unsigned int state, v;

  394.     int val, n;

  395. 

  396.     state = *header_state;

  397.     n = *size_ptr;

  398.     while (n > 0) {

  399.         if (url_feof(pb))

  400.             break;

  401.         v = get_byte(pb);

  402.         n--;

  403.         if (state == 0x000001) {

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

  405.             val = state;

  406.             goto found;

  407.         }

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

  409.     }

  410.     val = -1;

  411.  found:

  412.     *header_state = state;

  413.     *size_ptr = n;

  414.     return val;

  415. }

  416. 

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

  418. {

  419.     AVStream *st;

  420.     int i;

  421.     

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

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

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

  425.             return 1;

  426.     }

  427.     return 0;   

  428. }

  429. 

  430. static int mpeg_mux_read_header(AVFormatContext *s,

  431.                                 AVFormatParameters *ap)

  432. {

  433.     MpegDemuxContext *m;

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

  435.     int codec_id, n, i, type;

  436.     AVStream *st;

  437.     offset_t start_pos;

  438. 

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

  440.     if (!m)

  441.         return -ENOMEM;

  442.     s->priv_data = m;

  443. 

  444.     /* search first pack header */

  445.     m->header_state = 0xff;

  446.     size = MAX_SYNC_SIZE;

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

  448.     for(;;) {

  449.         while (size > 0) {

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

  451.             if (startcode == PACK_START_CODE)

  452.                 goto found;

  453.         }

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

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

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

  457.         video_bound = 0;

  458.         audio_bound = 0;

  459.         c = 0;

  460.         s->nb_streams = 0;

  461.         size = 15*MAX_SYNC_SIZE;

  462.         while (size > 0) {

  463.             type = 0;

  464.             codec_id = 0;

  465.             n = 0;

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

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

  468.             if (startcode == 0x1bd) {

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

  470.                 size += 4;

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

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

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

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

  475.                     type = CODEC_TYPE_AUDIO;

  476.                     codec_id = CODEC_ID_AC3;

  477.                     audio_bound++;

  478.                     n = 1;

  479.                     c = startcode;

  480.                 }    

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

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

  483.                 type = CODEC_TYPE_VIDEO;

  484.                 codec_id = CODEC_ID_MPEG1VIDEO;

  485.                 n = 1;

  486.                 c = startcode;

  487.                 video_bound++;

  488.             } /*else if (startcode >= 0x1c0 && startcode <= 0x1df && !check_stream_id(s, startcode)) {

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

  490.                 type = CODEC_TYPE_AUDIO;

  491.                 codec_id = CODEC_ID_MP2;

  492.                 n = 1;

  493.                 c = startcode;

  494.                 audio_bound++;

  495.             } */

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

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

  498.                 if (!st)

  499.                     return -ENOMEM;

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

  501.                 st->id = c;

  502.                 st->codec.codec_type = type;

  503.                 st->codec.codec_id = codec_id;

  504.             }

  505.         }

  506.         if (video_bound || audio_bound) {

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

  508.             return 0;

  509.         } else

  510.             return -ENODATA;

  511.     found:

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

  513.         /* parse pack header */

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

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

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

  517. 

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

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

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

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

  522.         m->mux_rate = mux_rate;

  523. 

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

  525.         if (startcode == SYSTEM_HEADER_START_CODE)

  526.             break;

  527.     }

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

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

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

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

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

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

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

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

  536. #if 0

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

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

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

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

  541. #endif

  542.     size -= 6;

  543.     s->nb_streams = 0;

  544.     while (size > 0) {

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

  546.         size--;

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

  548.             break;

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

  550.         size -= 2;

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

  552.             /* mpeg audio stream */

  553.             type = CODEC_TYPE_AUDIO;

  554.             codec_id = CODEC_ID_MP2;

  555.             n = 1;

  556.             c = c | 0x100;

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

  558.             type = CODEC_TYPE_VIDEO;

  559.             codec_id = CODEC_ID_MPEG1VIDEO;

  560.             n = 1;

  561.             c = c | 0x100;

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

  563.             /* all audio streams */

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

  565.                know that this codec will be used */

  566.             type = CODEC_TYPE_AUDIO;

  567.             codec_id = CODEC_ID_AC3;

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

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

  570.             if (audio_bound == 0)

  571.             	audio_bound++;

  572.             n = audio_bound;

  573.             c = 0x80;

  574.             //c = 0x1c0;

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

  576.             /* all video streams */

  577.             type = CODEC_TYPE_VIDEO;

  578.             codec_id = CODEC_ID_MPEG1VIDEO;

  579.             n = video_bound;

  580.             c = 0x1e0;

  581.         } else {

  582.             type = 0;

  583.             codec_id = 0;

  584.             n = 0;

  585.         }

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

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

  588.             if (!st)

  589.                 return -ENOMEM;

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

  591.             st->id = c + i;

  592.             st->codec.codec_type = type;

  593.             st->codec.codec_id = codec_id;

  594.         }

  595.     }

  596. 

  597.     return 0;

  598. }

  599. 

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

  601. {

  602.     INT64 pts;

  603.     int val;

  604. 

  605.     if (c < 0)

  606.         c = get_byte(pb);

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

  608.     val = get_be16(pb);

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

  610.     val = get_be16(pb);

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

  612.     return pts;

  613. }

  614. 

  615. static int mpeg_mux_read_packet(AVFormatContext *s,

  616.                                 AVPacket *pkt)

  617. {

  618.     MpegDemuxContext *m = s->priv_data;

  619.     AVStream *st;

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

  621.     INT64 pts, dts;

  622. 

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

  624.  redo:

  625.     m->header_state = 0xff;

  626.     size = MAX_SYNC_SIZE;

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

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

  629.     if (startcode < 0)

  630.         return -EIO;

  631.     if (startcode == PACK_START_CODE)

  632.         goto redo;

  633.     if (startcode == SYSTEM_HEADER_START_CODE)

  634.         goto redo;

  635.     if (startcode == PADDING_STREAM ||

  636.         startcode == PRIVATE_STREAM_2) {

  637.         /* skip them */

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

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

  640.         goto redo;

  641.     }

  642.     /* find matching stream */

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

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

  645.           (startcode == 0x1bd)))

  646.         goto redo;

  647. 

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

  649.     pts = 0;

  650.     dts = 0;

  651.     /* stuffing */

  652.     for(;;) {

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

  654.         len--;

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

  656.         if (c != 0xff) 

  657.             break;

  658.     }

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

  660.         /* buffer scale & size */

  661.         get_byte(&s->pb);

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

  663.         len -= 2;

  664.     }

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

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

  667.         len -= 4;

  668.         dts = pts;

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

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

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

  672.         len -= 9;

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

  674.         /* mpeg 2 PES */

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

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

  677.             return -EIO;

  678.         }

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

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

  681.         len -= 2;

  682.         if (header_len > len)

  683.             goto redo;

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

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

  686.             dts = pts;

  687.             header_len -= 5;

  688.             len -= 5;

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

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

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

  692.             header_len -= 10;

  693.             len -= 10;

  694.         }

  695.         len -= header_len;

  696.         while (header_len > 0) {

  697.             get_byte(&s->pb);

  698.             header_len--;

  699.         }

  700.     }

  701.     if (startcode == 0x1bd) {

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

  703.         len--;

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

  705.             /* audio: skip header */

  706.             get_byte(&s->pb);

  707.             get_byte(&s->pb);

  708.             get_byte(&s->pb);

  709.             len -= 3;

  710.         }

  711.     }

  712. 

  713.     /* now find stream */

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

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

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

  717.             goto found;

  718.     }

  719.     /* skip packet */

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

  721.     goto redo;

  722.  found:

  723.     av_new_packet(pkt, len);

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

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

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

  727.     pkt->pts = pts;

  728.     pkt->stream_index = i;

  729.     return 0;

  730. }

  731. 

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

  733. {

  734.     MpegDemuxContext *m = s->priv_data;

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

  736.     INT64 pts, dts;

  737. 

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

  739.  redo:

  740.     m->header_state = 0xff;

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

  742.     

  743.     if (startcode < 0)

  744.         return -EIO;

  745.     if (startcode == PACK_START_CODE)

  746.         goto redo;

  747.     if (startcode == SYSTEM_HEADER_START_CODE)

  748.         goto redo;

  749.     if (startcode == PADDING_STREAM ||

  750.         startcode == PRIVATE_STREAM_2) {

  751.         /* skip them */

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

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

  754.         goto redo;

  755.     }

  756.     /* find matching stream */

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

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

  759.           (startcode == 0x1bd)))

  760.         goto redo;

  761. 

  762.     n = *size;

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

  764.     n -= 2;

  765.     pts = 0;

  766.     dts = 0;

  767.     /* stuffing */

  768.     for(;;) {

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

  770.         len--;

  771.         n--;

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

  773.         if (c != 0xff) 

  774.             break;

  775.     }

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

  777.         /* buffer scale & size */

  778.         get_byte(&s->pb);

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

  780.         len -= 2;

  781.         n -= 2;

  782.     }

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

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

  785.         len -= 4;

  786.         n -= 4;

  787.         dts = pts;

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

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

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

  791.         len -= 9;

  792.         n -= 9;

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

  794.         /* mpeg 2 PES */

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

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

  797.             return -EIO;

  798.         }

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

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

  801.         len -= 2;

  802.         n -= 2;

  803.         if (header_len > len)

  804.             goto redo;

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

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

  807.             dts = pts;

  808.             header_len -= 5;

  809.             len -= 5;

  810.             n -= 5;

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

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

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

  814.             header_len -= 10;

  815.             len -= 10;

  816.             n -= 10;

  817.         }

  818.         len -= header_len;

  819.         n -= header_len;

  820.         while (header_len > 0) {

  821.             get_byte(&s->pb);

  822.             header_len--;

  823.         }

  824.     }

  825.     if (startcode == 0x1bd) {

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

  827.         len--;

  828.         n--;

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

  830.             /* audio: skip header */

  831.             get_byte(&s->pb);

  832.             get_byte(&s->pb);

  833.             get_byte(&s->pb);

  834.             len -= 3;

  835.             n -= 3;

  836.         }

  837.     }

  838.     *size = n;

  839.     return startcode;

  840. }

  841. 

  842. 

  843. static int mpeg_mux_read_close(AVFormatContext *s)

  844. {

  845.     MpegDemuxContext *m = s->priv_data;

  846.     free(m);

  847.     return 0;

  848. }

  849. 

  850. AVFormat mpeg_mux_format = {

  851.     "mpeg",

  852.     "MPEG multiplex format",

  853.     "video/x-mpeg",

  854.     "mpg,mpeg,vob",

  855.     CODEC_ID_MP2,

  856.     CODEC_ID_MPEG1VIDEO,

  857.     mpeg_mux_init,

  858.     mpeg_mux_write_packet,

  859.     mpeg_mux_end,

  860. 

  861.     mpeg_mux_read_header,

  862.     mpeg_mux_read_packet,

  863.     mpeg_mux_read_close,

  864. };