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

867 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, seems_dvd;

  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.     seems_dvd = 0;

  444.     

  445.     /* search first pack header */

  446.     m->header_state = 0xff;

  447.     size = MAX_SYNC_SIZE;

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

  449.     for(;;) {

  450.         /*while (size > 0) {

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

  452.             if (startcode == PACK_START_CODE)

  453.                 goto found;

  454.         }*/

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

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

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

  458.         video_bound = 0;

  459.         audio_bound = 0;

  460.         c = 0;

  461.         s->nb_streams = 0;

  462.         //size = 15*MAX_SYNC_SIZE;

  463.         while (size > 0) {

  464.             type = 0;

  465.             codec_id = 0;

  466.             n = 0;

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

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

  469.             if (startcode == 0x1bd) {

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

  471.                 size += 4;

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

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

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

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

  476.                     type = CODEC_TYPE_AUDIO;

  477.                     codec_id = CODEC_ID_AC3;

  478.                     audio_bound++;

  479.                     n = 1;

  480.                     c = startcode;

  481.                     seems_dvd = 1;

  482.                 }    

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

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

  485.                 type = CODEC_TYPE_VIDEO;

  486.                 codec_id = CODEC_ID_MPEG1VIDEO;

  487.                 n = 1;

  488.                 c = startcode;

  489.                 video_bound++;

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

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

  492.                 type = CODEC_TYPE_AUDIO;

  493.                 codec_id = CODEC_ID_MP2;

  494.                 n = 1;

  495.                 c = startcode;

  496.                 audio_bound++;

  497.             } 

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

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

  500.                 if (!st)

  501.                     return -ENOMEM;

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

  503.                 st->id = c;

  504.                 st->codec.codec_type = type;

  505.                 st->codec.codec_id = codec_id;

  506.             }

  507.         }

  508.         if (video_bound || audio_bound) {

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

  510.             return 0;

  511.         } else

  512.             return -ENODATA;

  513.     found:

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

  515.         /* parse pack header */

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

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

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

  519. 

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

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

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

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

  524.         m->mux_rate = mux_rate;

  525. 

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

  527.         if (startcode == SYSTEM_HEADER_START_CODE)

  528.             break;

  529.     }

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

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

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

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

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

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

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

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

  538. #if 0

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

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

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

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

  543. #endif

  544.     size -= 6;

  545.     s->nb_streams = 0;

  546.     while (size > 0) {

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

  548.         size--;

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

  550.             break;

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

  552.         size -= 2;

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

  554.             /* mpeg audio stream */

  555.             type = CODEC_TYPE_AUDIO;

  556.             codec_id = CODEC_ID_MP2;

  557.             n = 1;

  558.             c = c | 0x100;

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

  560.             type = CODEC_TYPE_VIDEO;

  561.             codec_id = CODEC_ID_MPEG1VIDEO;

  562.             n = 1;

  563.             c = c | 0x100;

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

  565.             /* all audio streams */

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

  567.                know that this codec will be used */

  568.             type = CODEC_TYPE_AUDIO;

  569.             codec_id = CODEC_ID_AC3;

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

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

  572.             if (audio_bound == 0)

  573.             	audio_bound++;

  574.             n = audio_bound;

  575.             c = 0x80;

  576.             //c = 0x1c0;

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

  578.             /* all video streams */

  579.             type = CODEC_TYPE_VIDEO;

  580.             codec_id = CODEC_ID_MPEG1VIDEO;

  581.             n = video_bound;

  582.             c = 0x1e0;

  583.         } else {

  584.             type = 0;

  585.             codec_id = 0;

  586.             n = 0;

  587.         }

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

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

  590.             if (!st)

  591.                 return -ENOMEM;

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

  593.             st->id = c + i;

  594.             st->codec.codec_type = type;

  595.             st->codec.codec_id = codec_id;

  596.         }

  597.     }

  598. 

  599.     return 0;

  600. }

  601. 

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

  603. {

  604.     INT64 pts;

  605.     int val;

  606. 

  607.     if (c < 0)

  608.         c = get_byte(pb);

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

  610.     val = get_be16(pb);

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

  612.     val = get_be16(pb);

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

  614.     return pts;

  615. }

  616. 

  617. static int mpeg_mux_read_packet(AVFormatContext *s,

  618.                                 AVPacket *pkt)

  619. {

  620.     MpegDemuxContext *m = s->priv_data;

  621.     AVStream *st;

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

  623.     INT64 pts, dts;

  624. 

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

  626.  redo:

  627.     m->header_state = 0xff;

  628.     size = MAX_SYNC_SIZE;

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

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

  631.     if (startcode < 0)

  632.         return -EIO;

  633.     if (startcode == PACK_START_CODE)

  634.         goto redo;

  635.     if (startcode == SYSTEM_HEADER_START_CODE)

  636.         goto redo;

  637.     if (startcode == PADDING_STREAM ||

  638.         startcode == PRIVATE_STREAM_2) {

  639.         /* skip them */

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

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

  642.         goto redo;

  643.     }

  644.     /* find matching stream */

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

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

  647.           (startcode == 0x1bd)))

  648.         goto redo;

  649. 

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

  651.     pts = 0;

  652.     dts = 0;

  653.     /* stuffing */

  654.     for(;;) {

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

  656.         len--;

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

  658.         if (c != 0xff) 

  659.             break;

  660.     }

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

  662.         /* buffer scale & size */

  663.         get_byte(&s->pb);

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

  665.         len -= 2;

  666.     }

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

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

  669.         len -= 4;

  670.         dts = pts;

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

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

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

  674.         len -= 9;

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

  676.         /* mpeg 2 PES */

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

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

  679.             return -EIO;

  680.         }

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

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

  683.         len -= 2;

  684.         if (header_len > len)

  685.             goto redo;

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

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

  688.             dts = pts;

  689.             header_len -= 5;

  690.             len -= 5;

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

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

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

  694.             header_len -= 10;

  695.             len -= 10;

  696.         }

  697.         len -= header_len;

  698.         while (header_len > 0) {

  699.             get_byte(&s->pb);

  700.             header_len--;

  701.         }

  702.     }

  703.     if (startcode == 0x1bd) {

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

  705.         len--;

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

  707.             /* audio: skip header */

  708.             get_byte(&s->pb);

  709.             get_byte(&s->pb);

  710.             get_byte(&s->pb);

  711.             len -= 3;

  712.         }

  713.     }

  714. 

  715.     /* now find stream */

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

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

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

  719.             goto found;

  720.     }

  721.     /* skip packet */

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

  723.     goto redo;

  724.  found:

  725.     av_new_packet(pkt, len);

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

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

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

  729.     pkt->pts = pts;

  730.     pkt->stream_index = i;

  731.     return 0;

  732. }

  733. 

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

  735. {

  736.     MpegDemuxContext *m = s->priv_data;

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

  738.     INT64 pts, dts;

  739. 

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

  741.  redo:

  742.     m->header_state = 0xff;

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

  744.     

  745.     if (startcode < 0)

  746.         return -EIO;

  747.     if (startcode == PACK_START_CODE)

  748.         goto redo;

  749.     if (startcode == SYSTEM_HEADER_START_CODE)

  750.         goto redo;

  751.     if (startcode == PADDING_STREAM ||

  752.         startcode == PRIVATE_STREAM_2) {

  753.         /* skip them */

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

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

  756.         goto redo;

  757.     }

  758.     /* find matching stream */

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

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

  761.           (startcode == 0x1bd)))

  762.         goto redo;

  763. 

  764.     n = *size;

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

  766.     n -= 2;

  767.     pts = 0;

  768.     dts = 0;

  769.     /* stuffing */

  770.     for(;;) {

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

  772.         len--;

  773.         n--;

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

  775.         if (c != 0xff) 

  776.             break;

  777.     }

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

  779.         /* buffer scale & size */

  780.         get_byte(&s->pb);

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

  782.         len -= 2;

  783.         n -= 2;

  784.     }

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

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

  787.         len -= 4;

  788.         n -= 4;

  789.         dts = pts;

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

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

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

  793.         len -= 9;

  794.         n -= 9;

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

  796.         /* mpeg 2 PES */

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

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

  799.             return -EIO;

  800.         }

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

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

  803.         len -= 2;

  804.         n -= 2;

  805.         if (header_len > len)

  806.             goto redo;

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

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

  809.             dts = pts;

  810.             header_len -= 5;

  811.             len -= 5;

  812.             n -= 5;

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

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

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

  816.             header_len -= 10;

  817.             len -= 10;

  818.             n -= 10;

  819.         }

  820.         len -= header_len;

  821.         n -= header_len;

  822.         while (header_len > 0) {

  823.             get_byte(&s->pb);

  824.             header_len--;

  825.         }

  826.     }

  827.     if (startcode == 0x1bd) {

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

  829.         len--;

  830.         n--;

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

  832.             /* audio: skip header */

  833.             get_byte(&s->pb);

  834.             get_byte(&s->pb);

  835.             get_byte(&s->pb);

  836.             len -= 3;

  837.             n -= 3;

  838.         }

  839.     }

  840.     *size = n;

  841.     return startcode;

  842. }

  843. 

  844. 

  845. static int mpeg_mux_read_close(AVFormatContext *s)

  846. {

  847.     MpegDemuxContext *m = s->priv_data;

  848.     free(m);

  849.     return 0;

  850. }

  851. 

  852. AVFormat mpeg_mux_format = {

  853.     "mpeg",

  854.     "MPEG multiplex format",

  855.     "video/x-mpeg",

  856.     "mpg,mpeg,vob",

  857.     CODEC_ID_MP2,

  858.     CODEC_ID_MPEG1VIDEO,

  859.     mpeg_mux_init,

  860.     mpeg_mux_write_packet,

  861.     mpeg_mux_end,

  862. 

  863.     mpeg_mux_read_header,

  864.     mpeg_mux_read_packet,

  865.     mpeg_mux_read_close,

  866. };