开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
asfenc.c
资源名称：ffmpeg-0.3.4.tar.gz　[点击查看]
上传用户：jxp0626
上传日期：2007-01-08
资源大小：102k
文件大小：14k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Unix_Linux

asfenc.c：源码内容
  1. /*
  2.  * ASF compatible encoder
  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 <stdlib.h>
  20. #include <stdio.h>
  21. #include <netinet/in.h>
  22. #include <string.h>
  23. #include "mpegenc.h"
  25. #define PACKET_SIZE 3200
  26. #define PACKET_HEADER_SIZE 12
  27. #define FRAME_HEADER_SIZE 17
  29. typedef struct {
  30.     AVEncodeContext *enc;
  31.     int num;
  32.     int seq;
  33. } ASFStream;
  35. typedef struct {
  36.     int seqno;
  37.     int packet_size;
  39.     ASFStream streams[2];
  40.     ASFStream *audio_stream, *video_stream;
  41.     int nb_streams;
  42.     /* non streamed additonnal info */
  43.     int file_size_offset;
  44.     int data_offset;
  45.     /* packet filling */
  46.     int packet_size_left;
  47.     int packet_timestamp_start;
  48.     int packet_timestamp_end;
  49.     int packet_nb_frames;
  50.     UINT8 packet_buf[PACKET_SIZE];
  51.     PutByteContext pb;
  52. } ASFContext;
  54. typedef struct {
  55.     UINT32 v1;
  56.     UINT16 v2;
  57.     UINT16 v3;
  58.     UINT8 v4[8];
  59. } GUID;
  61. static const GUID asf_header = {
  62.     0x75B22630, 0x668E, 0x11CF, { 0xA6, 0xD9, 0x00, 0xAA, 0x00, 0x62, 0xCE, 0x6C },
  63. };
  65. static const GUID file_header = {
  66.     0x8CABDCA1, 0xA947, 0x11CF, { 0x8E, 0xE4, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65 },
  67. };
  69. static const GUID stream_header = {
  70.     0xB7DC0791, 0xA9B7, 0x11CF, { 0x8E, 0xE6, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65 },
  71. };
  73. static const GUID audio_stream = {
  74.     0xF8699E40, 0x5B4D, 0x11CF, { 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B },
  75. };
  77. static const GUID audio_conceal_none = {
  78.     0x49f1a440, 0x4ece, 0x11d0, { 0xa3, 0xac, 0x00, 0xa0, 0xc9, 0x03, 0x48, 0xf6 },
  79. };
  81. static const GUID video_stream = {
  82.     0xBC19EFC0, 0x5B4D, 0x11CF, { 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B },
  83. };
  85. static const GUID video_conceal_none = {
  86.     0x20FB5700, 0x5B55, 0x11CF, { 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B },
  87. };
  89. static const GUID comment_header = {
  90.     0x86D15240, 0x311D, 0x11D0, { 0xA3, 0xA4, 0x00, 0xA0, 0xC9, 0x03, 0x48, 0xF6 },
  91. };
  93. static const GUID data_header = {
  94.     0x75b22636, 0x668e, 0x11cf, { 0xa6, 0xd9, 0x00, 0xaa, 0x00, 0x62, 0xce, 0x6c },
  95. };
  97. static const GUID packet_guid = {
  98.     0xF656CCE1, 0x03B3, 0x11D4, { 0xBE, 0xA2, 0x00, 0xA0, 0xCC, 0x3D, 0x72, 0x74 },
  99. };
  100.     
  101. /* I am not a number !!! This GUID is the one found on the PC used to
  102.    generate the stream */
  103. static const GUID my_guid = {
  104.     0x12345678, 0xA947, 0x11CF, { 0x31, 0x41, 0x59, 0x26, 0x20, 0x20, 0x20, 0x20 },
  105. };
  107. static void put_guid(PutByteContext *s, const GUID *g)
  108. {
  109.     int i;
  111.     put_le32(s, g->v1);
  112.     put_le16(s, g->v2);
  113.     put_le16(s, g->v3);
  114.     for(i=0;i<8;i++)
  115.         put_byte(s, g->v4[i]);
  116. }
  118. #if 0
  119. static void put_str16(PutByteContext *s, const char *tag)
  120. {
  121.     put_le16(s,strlen(tag));
  122.     while (*tag) {
  123.         put_le16(s, *tag++);
  124.     }
  125. }
  126. #endif
  128. /* write an asf chunk (only used in streaming case) */
  129. static void put_chunk(AVFormatContext *s, int type, int payload_length)
  130. {
  131.     ASFContext *asf = s->priv_data;
  132.     PutByteContext *pb = &s->pb;
  133.     int length;
  135.     length = payload_length + 8;
  136.     put_le16(pb, type); 
  137.     put_le16(pb, length); 
  138.     put_le32(pb, asf->seqno);
  139.     put_le16(pb, 0); /* unknown bytes */
  140.     put_le16(pb, length);
  141.     asf->seqno++;
  142. }
  145. static int asf_write_header(AVFormatContext *s)
  146. {
  147.     PutByteContext *pb = &s->pb;
  148.     ASFContext *asf;
  149.     int header_size, n, extra_size, extra_size2, i, wav_extra_size;
  150.     AVEncodeContext *enc;
  151.     long long header_offset, cur_pos;
  153.     asf = malloc(sizeof(ASFContext));
  154.     if (!asf)
  155.         return -1;
  156.     memset(asf, 0, sizeof(ASFContext));
  157.     s->priv_data = asf;
  159.     asf->packet_size = PACKET_SIZE;
  161.     if (!s->is_streamed) {
  162.         put_guid(pb, &asf_header);
  163.         put_le64(pb, 0); /* header length, will be patched after */
  164.         put_le32(pb, 6); /* ??? */
  165.         put_byte(pb, 1); /* ??? */
  166.         put_byte(pb, 2); /* ??? */
  167.     } else {
  168.         put_chunk(s, 0x4824, 0); /* start of stream (length will be patched later) */
  169.     }
  170.     
  171.     /* file header */
  172.     header_offset = put_pos(pb);
  173.     put_guid(pb, &file_header);
  174.     put_le64(pb, 24 + 80);
  175.     put_guid(pb, &my_guid);
  176.     asf->file_size_offset = put_pos(pb);
  177.     put_le64(pb, 0); /* file size (patched after if not streamed) */
  178.     put_le64(pb, 0); /* file time : 1601 :-) */
  179.     put_le64(pb, 0x283); /* ??? */
  180.     put_le64(pb, 0); /* stream 0 length in us */
  181.     put_le64(pb, 0); /* stream 1 length in us */
  182.     put_le32(pb, 0x0c1c); /* ??? */
  183.     put_le32(pb, 0); /* ??? */
  184.     put_le32(pb, 2); /* ??? */
  185.     put_le32(pb, asf->packet_size); /* packet size */
  186.     put_le32(pb, asf->packet_size); /* ??? */
  187.     put_le32(pb, 0x03e800); /* ??? */
  188.     
  189.     /* stream headers */
  190.     n = 0;
  191.     for(i=0;i<2;i++) {
  192.         if (i == 0)
  193.             enc = s->audio_enc;
  194.         else
  195.             enc = s->video_enc;
  196.         
  197.         if (!enc)
  198.             continue;
  199.         asf->streams[n].num = n + 1;
  200.         asf->streams[n].seq = 0;
  201.         asf->streams[n].enc = enc;
  202.         
  203.         switch(enc->codec->type) {
  204.         case CODEC_TYPE_AUDIO:
  205.             asf->audio_stream = &asf->streams[n];
  206.             wav_extra_size = 0;
  207.             extra_size = 18 + wav_extra_size;
  208.             extra_size2 = 0;
  209.             break;
  210.         default:
  211.         case CODEC_TYPE_VIDEO:
  212.             asf->video_stream = &asf->streams[n];
  213.             wav_extra_size = 0;
  214.             extra_size = 0x33;
  215.             extra_size2 = 0;
  216.             break;
  217.         }
  219.         put_guid(pb, &stream_header);
  220.         put_le64(pb, 24 + 16 * 2 + 22 + extra_size + extra_size2);
  221.         if (enc->codec->type == CODEC_TYPE_AUDIO) {
  222.             put_guid(pb, &audio_stream);
  223.             put_guid(pb, &audio_conceal_none);
  224.         } else {
  225.             put_guid(pb, &video_stream);
  226.             put_guid(pb, &video_conceal_none);
  227.         }
  228.         put_le64(pb, 0); /* ??? */
  229.         put_le32(pb, extra_size); /* wav header len */
  230.         put_le32(pb, extra_size2); /* additional data len */
  231.         put_le16(pb, n + 1); /* stream number */
  232.         put_le32(pb, 0); /* ??? */
  233.         
  234.         if (enc->codec->type == CODEC_TYPE_AUDIO) {
  235.             /* WAVEFORMATEX header */
  236.             put_wav_header(pb, enc);
  237.         } else {
  238.             put_le32(pb, enc->width);
  239.             put_le32(pb, enc->height);
  240.             put_byte(pb, 2); /* ??? */
  241.             put_le16(pb, 40); /* size */
  243.             /* BITMAPINFOHEADER header */
  244.             put_bmp_header(pb, enc);
  245.         }
  246.         n++;
  247.     }
  248.     asf->nb_streams = n;
  250.     /* XXX: should put media comments */
  251. #if 0
  252.     put_guid(pb, &comment_header);
  253.     put_le64(pb, 0);
  254. #endif
  255.     /* patch the header size fields */
  257.     cur_pos = put_pos(pb);
  258.     header_size = cur_pos - header_offset;
  259.     if (!s->is_streamed) {
  260.         header_size += 24 + 6;
  261.         put_seek(pb, header_offset - 14, SEEK_SET);
  262.         put_le64(pb, header_size);
  263.     } else {
  264.         header_size += 8 + 50;
  265.         put_seek(pb, header_offset - 10, SEEK_SET);
  266.         put_le16(pb, header_size);
  267.         put_seek(pb, header_offset - 2, SEEK_SET);
  268.         put_le16(pb, header_size);
  269.     }
  270.     put_seek(pb, cur_pos, SEEK_SET);
  272.     /* movie chunk, followed by packets of packet_size */
  273.     asf->data_offset = cur_pos;
  274.     put_guid(pb, &data_header);
  275.     put_le64(pb, 24); /* will be patched after */
  276.     put_guid(pb, &packet_guid);
  277.     put_le64(pb, 0x283); /* ??? */
  278.     put_byte(pb, 1); /* ??? */
  279.     put_byte(pb, 1); /* ??? */
  281.     put_flush_packet(&s->pb);
  283.     asf->packet_nb_frames = 0;
  284.     asf->packet_timestamp_start = -1;
  285.     asf->packet_timestamp_end = -1;
  286.     asf->packet_size_left = asf->packet_size - PACKET_HEADER_SIZE;
  287.     init_put_byte(&asf->pb, asf->packet_buf, asf->packet_size,
  288.                   NULL, NULL, NULL);
  290.     return 0;
  291. }
  293. /* write a fixed size packet */
  294. static void put_packet(AVFormatContext *s, 
  295.                        unsigned int timestamp, unsigned int duration, 
  296.                        int nb_frames, int padsize)
  297. {
  298.     ASFContext *asf = s->priv_data;
  299.     PutByteContext *pb = &s->pb;
  300.     int flags;
  302.     if (s->is_streamed) {
  303.         put_chunk(s, 0x4424, asf->packet_size);
  304.     }
  306.     put_byte(pb, 0x82);
  307.     put_le16(pb, 0);
  308.     
  309.     flags = 0x01; /* nb segments present */
  310.     if (padsize > 0) {
  311.         if (padsize < 256)
  312.             flags |= 0x08;
  313.         else
  314.             flags |= 0x10;
  315.     }
  316.     put_byte(pb, flags); /* flags */
  317.     put_byte(pb, 0x5d);
  318.     if (flags & 0x10)
  319.         put_le16(pb, padsize);
  320.     if (flags & 0x08)
  321.         put_byte(pb, padsize);
  322.     put_le32(pb, timestamp);
  323.     put_le16(pb, duration);
  324.     put_byte(pb, nb_frames | 0x80);
  325. }
  327. static void flush_packet(AVFormatContext *s)
  328. {
  329.     ASFContext *asf = s->priv_data;
  330.     int hdr_size, ptr;
  331.     
  332.     put_packet(s, asf->packet_timestamp_start, 
  333.                asf->packet_timestamp_end - asf->packet_timestamp_start, 
  334.                asf->packet_nb_frames, asf->packet_size_left);
  335.     
  336.     /* compute padding */
  337.     hdr_size = PACKET_HEADER_SIZE;
  338.     if (asf->packet_size_left > 0) {
  339.         /* if padding needed, don't forget to count the
  340.            padding byte in the header size */
  341.         hdr_size++;
  342.         asf->packet_size_left--;
  343.         /* XXX: I do not test again exact limit to avoid boundary problems */
  344.         if (asf->packet_size_left > 200) {
  345.             hdr_size++;
  346.             asf->packet_size_left--;
  347.         }
  348.     }
  349.     ptr = asf->packet_size - PACKET_HEADER_SIZE - asf->packet_size_left;
  350.     memset(asf->packet_buf + ptr, 0, asf->packet_size_left);
  351.     
  352.     put_buffer(&s->pb, asf->packet_buf, asf->packet_size - hdr_size);
  353.     
  354.     put_flush_packet(&s->pb);
  355.     asf->packet_nb_frames = 0;
  356.     asf->packet_timestamp_start = -1;
  357.     asf->packet_timestamp_end = -1;
  358.     asf->packet_size_left = asf->packet_size - PACKET_HEADER_SIZE;
  359.     init_put_byte(&asf->pb, asf->packet_buf, asf->packet_size,
  360.                   NULL, NULL, NULL);
  361. }
  363. static void put_frame_header(AVFormatContext *s, ASFStream *stream, int timestamp,
  364.                              int payload_size, int frag_offset, int frag_len)
  365. {
  366.     ASFContext *asf = s->priv_data;
  367.     PutByteContext *pb = &asf->pb;
  368.     int val;
  370.     val = stream->num;
  371.     if (stream->enc->key_frame)
  372.         val |= 0x80;
  373.     put_byte(pb, val);
  374.     put_byte(pb, stream->seq);
  375.     put_le32(pb, frag_offset); /* fragment offset */
  376.     put_byte(pb, 0x08); /* flags */
  377.     put_le32(pb, payload_size);
  378.     put_le32(pb, timestamp);
  379.     put_le16(pb, frag_len);
  380. }
  383. /* Output a frame. We suppose that payload_size <= PACKET_SIZE.
  385.    It is there that you understand that the ASF format is really
  386.    crap. They have misread the MPEG Systems spec ! 
  387.  */
  388. static void put_frame(AVFormatContext *s, ASFStream *stream, int timestamp,
  389.                       UINT8 *buf, int payload_size)
  390. {
  391.     ASFContext *asf = s->priv_data;
  392.     int frag_pos, frag_len, frag_len1;
  393.     
  394.     frag_pos = 0;
  395.     while (frag_pos < payload_size) {
  396.         frag_len = payload_size - frag_pos;
  397.         frag_len1 = asf->packet_size_left - FRAME_HEADER_SIZE;
  398.         if (frag_len1 > 0) {
  399.             if (frag_len > frag_len1)
  400.                 frag_len = frag_len1;
  401.             put_frame_header(s, stream, timestamp, payload_size, frag_pos, frag_len);
  402.             put_buffer(&asf->pb, buf, frag_len);
  403.             asf->packet_size_left -= (frag_len + FRAME_HEADER_SIZE);
  404.             asf->packet_timestamp_end = timestamp;
  405.             if (asf->packet_timestamp_start == -1)
  406.                 asf->packet_timestamp_start = timestamp;
  407.             asf->packet_nb_frames++;
  408.         } else {
  409.             frag_len = 0;
  410.         }
  411.         frag_pos += frag_len;
  412.         buf += frag_len;
  413.         /* output the frame if filled */
  414.         if (asf->packet_size_left <= FRAME_HEADER_SIZE)
  415.             flush_packet(s);
  416.     }
  417.     stream->seq++;
  418. }
  421. static int asf_write_audio(AVFormatContext *s, UINT8 *buf, int size)
  422. {
  423.     ASFContext *asf = s->priv_data;
  424.     int timestamp;
  426.     timestamp = (int)((float)s->audio_enc->frame_number * s->audio_enc->frame_size * 1000.0 / 
  427.                       s->audio_enc->rate);
  428.     put_frame(s, asf->audio_stream, timestamp, buf, size);
  429.     return 0;
  430. }
  432. static int asf_write_video(AVFormatContext *s, UINT8 *buf, int size)
  433. {
  434.     ASFContext *asf = s->priv_data;
  435.     int timestamp;
  437.     timestamp = (int)((float)s->video_enc->frame_number * 1000.0 / 
  438.                       s->video_enc->rate);
  439.     put_frame(s, asf->video_stream, timestamp, buf, size);
  440.     return 0;
  441. }
  443. static int asf_write_trailer(AVFormatContext *s)
  444. {
  445.     ASFContext *asf = s->priv_data;
  446.     long long file_size;
  448.     /* flush the current packet */
  449.     if (asf->pb.buf_ptr > asf->pb.buffer)
  450.         flush_packet(s);
  452.     if (s->is_streamed) {
  453.         put_chunk(s, 0x4524, 0); /* end of stream */
  454.     } else {
  455.         /* patch the various place which depends on the file size */
  456.         file_size = put_pos(&s->pb);
  457.         put_seek(&s->pb, asf->file_size_offset, SEEK_SET);
  458.         put_le64(&s->pb, file_size);
  459.         put_seek(&s->pb, asf->data_offset + 16, SEEK_SET);
  460.         put_le64(&s->pb, file_size - asf->data_offset);
  461.     }
  463.     put_flush_packet(&s->pb);
  465.     free(asf);
  466.     return 0;
  467. }
  469. AVFormat asf_format = {
  470.     "asf",
  471.     "asf format",
  472.     "application/octet-stream",
  473.     "asf",
  474.     CODEC_ID_MP2,
  475.     CODEC_ID_DIVX,
  476.     asf_write_header,
  477.     asf_write_audio,
  478.     asf_write_video,
  479.     asf_write_trailer,
  480. };