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.
530 Commits
32 Branches
944MB
Tree: 10bb7023a2
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '10bb7023a2'
${ noResults }
FFmpeg/libav/mpeg.c

861 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.         }

  195.     }

  196. 

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

  198.        headers. XXX: compute it exactly */

  199.     bitrate = 2000;

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

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

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

  203.     }

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

  205.     /* every 2 seconds */

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

  207.     /* every 10 seconds */

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

  209. 

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

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

  212.         stream->buffer_ptr = 0;

  213.         stream->packet_number = 0;

  214.         stream->pts = 0;

  215.         stream->start_pts = -1;

  216. 

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

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

  219.         case CODEC_TYPE_AUDIO:

  220.             ticker_init(&stream->pts_ticker,

  221.                         st->codec.sample_rate,

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

  223.             break;

  224.         case CODEC_TYPE_VIDEO:

  225.             ticker_init(&stream->pts_ticker,

  226.                         st->codec.frame_rate,

  227.                         90000 * FRAME_RATE_BASE);

  228.             break;

  229.         }

  230.     }

  231.     return 0;

  232.  fail:

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

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

  235.     }

  236.     free(s);

  237.     return -ENOMEM;

  238. }

  239. 

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

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

  242. {

  243.     MpegMuxContext *s = ctx->priv_data;

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

  245.     UINT8 *buf_ptr;

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

  247.     INT64 timestamp;

  248.     UINT8 buffer[128];

  249. 

  250.     id = stream->id;

  251.     timestamp = stream->start_pts;

  252. 

  253. #if 0

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

  255.            id, timestamp / 90000.0);

  256. #endif

  257. 

  258.     buf_ptr = buffer;

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

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

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

  262.         buf_ptr += size;

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

  264.             size = put_system_header(ctx, buf_ptr);

  265.             buf_ptr += size;

  266.         }

  267.     }

  268.     size = buf_ptr - buffer;

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

  270. 

  271.     /* packet header */

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

  273.     if (id < 0xc0) {

  274.         startcode = PRIVATE_STREAM_1;

  275.         payload_size -= 4;

  276.     } else {

  277.         startcode = 0x100 + id;

  278.     }

  279.     stuffing_size = payload_size - stream->buffer_ptr;

  280.     if (stuffing_size < 0)

  281.         stuffing_size = 0;

  282. 

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

  284. 

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

  286.     /* stuffing */

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

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

  289.     

  290.     /* presentation time stamp */

  291.     put_byte(&ctx->pb, 

  292.              (0x02 << 4) | 

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

  294.              1);

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

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

  297. 

  298.     if (startcode == PRIVATE_STREAM_1) {

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

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

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

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

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

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

  305.         }

  306.     }

  307. 

  308.     /* output data */

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

  310.     put_flush_packet(&ctx->pb);

  311.     

  312.     /* preserve remaining data */

  313.     len = stream->buffer_ptr - payload_size;

  314.     if (len < 0) 

  315.         len = 0;

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

  317.     stream->buffer_ptr = len;

  318. 

  319.     s->packet_number++;

  320.     stream->packet_number++;

  321.     stream->start_pts = -1;

  322. }

  323. 

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

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

  326. {

  327.     MpegMuxContext *s = ctx->priv_data;

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

  329.     StreamInfo *stream = st->priv_data;

  330.     int len;

  331.     

  332.     while (size > 0) {

  333.         /* set pts */

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

  335.             if (force_pts)

  336.                 stream->pts = force_pts;

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

  338.         }

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

  340.         if (len > size)

  341.             len = size;

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

  343.         stream->buffer_ptr += len;

  344.         buf += len;

  345.         size -= len;

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

  347.             /* output the packet */

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

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

  350.             flush_packet(ctx, stream_index);

  351.         }

  352.     }

  353. 

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

  355.     return 0;

  356. }

  357. 

  358. static int mpeg_mux_end(AVFormatContext *ctx)

  359. {

  360.     StreamInfo *stream;

  361.     int i;

  362. 

  363.     /* flush each packet */

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

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

  366.         if (stream->buffer_ptr > 0) 

  367.             flush_packet(ctx, i);

  368.     }

  369. 

  370.     /* write the end header */

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

  372.     put_flush_packet(&ctx->pb);

  373.     return 0;

  374. }

  375. 

  376. /*********************************************/

  377. /* demux code */

  378. 

  379. #define MAX_SYNC_SIZE 100000

  380. 

  381. typedef struct MpegDemuxContext {

  382.     int header_state;

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

  384. } MpegDemuxContext;

  385. 

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

  387.                            UINT32 *header_state)

  388. {

  389.     unsigned int state, v;

  390.     int val, n;

  391. 

  392.     state = *header_state;

  393.     n = *size_ptr;

  394.     while (n > 0) {

  395.         if (url_feof(pb))

  396.             break;

  397.         v = get_byte(pb);

  398.         n--;

  399.         if (state == 0x000001) {

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

  401.             val = state;

  402.             goto found;

  403.         }

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

  405.     }

  406.     val = -1;

  407.  found:

  408.     *header_state = state;

  409.     *size_ptr = n;

  410.     return val;

  411. }

  412. 

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

  414. {

  415.     AVStream *st;

  416.     int i;

  417.     

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

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

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

  421.             return 1;

  422.     }

  423.     return 0;   

  424. }

  425. 

  426. static int mpeg_mux_read_header(AVFormatContext *s,

  427.                                 AVFormatParameters *ap)

  428. {

  429.     MpegDemuxContext *m;

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

  431.     int codec_id, n, i, type;

  432.     AVStream *st;

  433.     offset_t start_pos;

  434. 

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

  436.     if (!m)

  437.         return -ENOMEM;

  438.     s->priv_data = m;

  439. 

  440.     /* search first pack header */

  441.     m->header_state = 0xff;

  442.     size = MAX_SYNC_SIZE;

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

  444.     for(;;) {

  445.         while (size > 0) {

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

  447.             if (startcode == PACK_START_CODE)

  448.                 goto found;

  449.         }

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

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

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

  453.         video_bound = 0;

  454.         audio_bound = 0;

  455.         c = 0;

  456.         s->nb_streams = 0;

  457.         size = 15*MAX_SYNC_SIZE;

  458.         while (size > 0) {

  459.             type = 0;

  460.             codec_id = 0;

  461.             n = 0;

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

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

  464.             if (startcode == 0x1bd) {

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

  466.                 size += 4;

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

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

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

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

  471.                     type = CODEC_TYPE_AUDIO;

  472.                     codec_id = CODEC_ID_AC3;

  473.                     audio_bound++;

  474.                     n = 1;

  475.                     c = startcode;

  476.                 }    

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

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

  479.                 type = CODEC_TYPE_VIDEO;

  480.                 codec_id = CODEC_ID_MPEG1VIDEO;

  481.                 n = 1;

  482.                 c = startcode;

  483.                 video_bound++;

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

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

  486.                 type = CODEC_TYPE_AUDIO;

  487.                 codec_id = CODEC_ID_MP2;

  488.                 n = 1;

  489.                 c = startcode;

  490.                 audio_bound++;

  491.             } */

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

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

  494.                 if (!st)

  495.                     return -ENOMEM;

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

  497.                 st->id = c;

  498.                 st->codec.codec_type = type;

  499.                 st->codec.codec_id = codec_id;

  500.             }

  501.         }

  502.         if (video_bound || audio_bound) {

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

  504.             return 0;

  505.         } else

  506.             return -ENODATA;

  507.     found:

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

  509.         /* parse pack header */

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

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

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

  513. 

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

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

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

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

  518.         m->mux_rate = mux_rate;

  519. 

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

  521.         if (startcode == SYSTEM_HEADER_START_CODE)

  522.             break;

  523.     }

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

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

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

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

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

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

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

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

  532. #if 0

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

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

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

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

  537. #endif

  538.     size -= 6;

  539.     s->nb_streams = 0;

  540.     while (size > 0) {

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

  542.         size--;

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

  544.             break;

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

  546.         size -= 2;

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

  548.             /* mpeg audio stream */

  549.             type = CODEC_TYPE_AUDIO;

  550.             codec_id = CODEC_ID_MP2;

  551.             n = 1;

  552.             c = c | 0x100;

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

  554.             type = CODEC_TYPE_VIDEO;

  555.             codec_id = CODEC_ID_MPEG1VIDEO;

  556.             n = 1;

  557.             c = c | 0x100;

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

  559.             /* all audio streams */

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

  561.                know that this codec will be used */

  562.             type = CODEC_TYPE_AUDIO;

  563.             codec_id = CODEC_ID_AC3;

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

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

  566.             if (audio_bound == 0)

  567.             	audio_bound++;

  568.             n = audio_bound;

  569.             c = 0x80;

  570.             //c = 0x1c0;

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

  572.             /* all video streams */

  573.             type = CODEC_TYPE_VIDEO;

  574.             codec_id = CODEC_ID_MPEG1VIDEO;

  575.             n = video_bound;

  576.             c = 0x1e0;

  577.         } else {

  578.             type = 0;

  579.             codec_id = 0;

  580.             n = 0;

  581.         }

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

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

  584.             if (!st)

  585.                 return -ENOMEM;

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

  587.             st->id = c + i;

  588.             st->codec.codec_type = type;

  589.             st->codec.codec_id = codec_id;

  590.         }

  591.     }

  592. 

  593.     return 0;

  594. }

  595. 

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

  597. {

  598.     INT64 pts;

  599.     int val;

  600. 

  601.     if (c < 0)

  602.         c = get_byte(pb);

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

  604.     val = get_be16(pb);

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

  606.     val = get_be16(pb);

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

  608.     return pts;

  609. }

  610. 

  611. static int mpeg_mux_read_packet(AVFormatContext *s,

  612.                                 AVPacket *pkt)

  613. {

  614.     MpegDemuxContext *m = s->priv_data;

  615.     AVStream *st;

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

  617.     INT64 pts, dts;

  618. 

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

  620.  redo:

  621.     m->header_state = 0xff;

  622.     size = MAX_SYNC_SIZE;

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

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

  625.     if (startcode < 0)

  626.         return -EIO;

  627.     if (startcode == PACK_START_CODE)

  628.         goto redo;

  629.     if (startcode == SYSTEM_HEADER_START_CODE)

  630.         goto redo;

  631.     if (startcode == PADDING_STREAM ||

  632.         startcode == PRIVATE_STREAM_2) {

  633.         /* skip them */

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

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

  636.         goto redo;

  637.     }

  638.     /* find matching stream */

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

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

  641.           (startcode == 0x1bd)))

  642.         goto redo;

  643. 

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

  645.     pts = 0;

  646.     dts = 0;

  647.     /* stuffing */

  648.     for(;;) {

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

  650.         len--;

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

  652.         if (c != 0xff) 

  653.             break;

  654.     }

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

  656.         /* buffer scale & size */

  657.         get_byte(&s->pb);

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

  659.         len -= 2;

  660.     }

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

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

  663.         len -= 4;

  664.         dts = pts;

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

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

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

  668.         len -= 9;

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

  670.         /* mpeg 2 PES */

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

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

  673.             return -EIO;

  674.         }

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

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

  677.         len -= 2;

  678.         if (header_len > len)

  679.             goto redo;

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

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

  682.             dts = pts;

  683.             header_len -= 5;

  684.             len -= 5;

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

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

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

  688.             header_len -= 10;

  689.             len -= 10;

  690.         }

  691.         len -= header_len;

  692.         while (header_len > 0) {

  693.             get_byte(&s->pb);

  694.             header_len--;

  695.         }

  696.     }

  697.     if (startcode == 0x1bd) {

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

  699.         len--;

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

  701.             /* audio: skip header */

  702.             get_byte(&s->pb);

  703.             get_byte(&s->pb);

  704.             get_byte(&s->pb);

  705.             len -= 3;

  706.         }

  707.     }

  708. 

  709.     /* now find stream */

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

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

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

  713.             goto found;

  714.     }

  715.     /* skip packet */

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

  717.     goto redo;

  718.  found:

  719.     av_new_packet(pkt, len);

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

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

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

  723.     pkt->pts = pts;

  724.     pkt->stream_index = i;

  725.     return 0;

  726. }

  727. 

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

  729. {

  730.     MpegDemuxContext *m = s->priv_data;

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

  732.     INT64 pts, dts;

  733. 

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

  735.  redo:

  736.     m->header_state = 0xff;

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

  738.     

  739.     if (startcode < 0)

  740.         return -EIO;

  741.     if (startcode == PACK_START_CODE)

  742.         goto redo;

  743.     if (startcode == SYSTEM_HEADER_START_CODE)

  744.         goto redo;

  745.     if (startcode == PADDING_STREAM ||

  746.         startcode == PRIVATE_STREAM_2) {

  747.         /* skip them */

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

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

  750.         goto redo;

  751.     }

  752.     /* find matching stream */

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

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

  755.           (startcode == 0x1bd)))

  756.         goto redo;

  757. 

  758.     n = *size;

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

  760.     n -= 2;

  761.     pts = 0;

  762.     dts = 0;

  763.     /* stuffing */

  764.     for(;;) {

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

  766.         len--;

  767.         n--;

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

  769.         if (c != 0xff) 

  770.             break;

  771.     }

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

  773.         /* buffer scale & size */

  774.         get_byte(&s->pb);

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

  776.         len -= 2;

  777.         n -= 2;

  778.     }

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

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

  781.         len -= 4;

  782.         n -= 4;

  783.         dts = pts;

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

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

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

  787.         len -= 9;

  788.         n -= 9;

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

  790.         /* mpeg 2 PES */

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

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

  793.             return -EIO;

  794.         }

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

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

  797.         len -= 2;

  798.         n -= 2;

  799.         if (header_len > len)

  800.             goto redo;

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

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

  803.             dts = pts;

  804.             header_len -= 5;

  805.             len -= 5;

  806.             n -= 5;

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

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

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

  810.             header_len -= 10;

  811.             len -= 10;

  812.             n -= 10;

  813.         }

  814.         len -= header_len;

  815.         n -= header_len;

  816.         while (header_len > 0) {

  817.             get_byte(&s->pb);

  818.             header_len--;

  819.         }

  820.     }

  821.     if (startcode == 0x1bd) {

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

  823.         len--;

  824.         n--;

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

  826.             /* audio: skip header */

  827.             get_byte(&s->pb);

  828.             get_byte(&s->pb);

  829.             get_byte(&s->pb);

  830.             len -= 3;

  831.             n -= 3;

  832.         }

  833.     }

  834.     *size = n;

  835.     return startcode;

  836. }

  837. 

  838. 

  839. static int mpeg_mux_read_close(AVFormatContext *s)

  840. {

  841.     MpegDemuxContext *m = s->priv_data;

  842.     free(m);

  843.     return 0;

  844. }

  845. 

  846. AVFormat mpeg_mux_format = {

  847.     "mpeg",

  848.     "MPEG multiplex format",

  849.     "video/x-mpeg",

  850.     "mpg,mpeg,vob",

  851.     CODEC_ID_MP2,

  852.     CODEC_ID_MPEG1VIDEO,

  853.     mpeg_mux_init,

  854.     mpeg_mux_write_packet,

  855.     mpeg_mux_end,

  856. 

  857.     mpeg_mux_read_header,

  858.     mpeg_mux_read_packet,

  859.     mpeg_mux_read_close,

  860. };