• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • File List
  • Globals

libavformat/asfenc.c

Go to the documentation of this file.
00001 /*
00002  * ASF muxer
00003  * Copyright (c) 2000, 2001 Fabrice Bellard
00004  *
00005  * This file is part of FFmpeg.
00006  *
00007  * FFmpeg is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU Lesser General Public
00009  * License as published by the Free Software Foundation; either
00010  * version 2.1 of the License, or (at your option) any later version.
00011  *
00012  * FFmpeg is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015  * Lesser General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU Lesser General Public
00018  * License along with FFmpeg; if not, write to the Free Software
00019  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00020  */
00021 #include "avformat.h"
00022 #include "metadata.h"
00023 #include "riff.h"
00024 #include "asf.h"
00025 
00026 #undef NDEBUG
00027 #include <assert.h>
00028 
00029 
00030 #define ASF_INDEXED_INTERVAL    10000000
00031 #define ASF_INDEX_BLOCK         600
00032 
00033 #define ASF_PACKET_ERROR_CORRECTION_DATA_SIZE 0x2
00034 #define ASF_PACKET_ERROR_CORRECTION_FLAGS (\
00035                 ASF_PACKET_FLAG_ERROR_CORRECTION_PRESENT | \
00036                 ASF_PACKET_ERROR_CORRECTION_DATA_SIZE\
00037                 )
00038 
00039 #if (ASF_PACKET_ERROR_CORRECTION_FLAGS != 0)
00040 #   define ASF_PACKET_ERROR_CORRECTION_FLAGS_FIELD_SIZE 1
00041 #else
00042 #   define ASF_PACKET_ERROR_CORRECTION_FLAGS_FIELD_SIZE 0
00043 #endif
00044 
00045 #define ASF_PPI_PROPERTY_FLAGS (\
00046                 ASF_PL_FLAG_REPLICATED_DATA_LENGTH_FIELD_IS_BYTE | \
00047                 ASF_PL_FLAG_OFFSET_INTO_MEDIA_OBJECT_LENGTH_FIELD_IS_DWORD | \
00048                 ASF_PL_FLAG_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_IS_BYTE | \
00049                 ASF_PL_FLAG_STREAM_NUMBER_LENGTH_FIELD_IS_BYTE \
00050                 )
00051 
00052 #define ASF_PPI_LENGTH_TYPE_FLAGS 0
00053 
00054 #define ASF_PAYLOAD_FLAGS ASF_PL_FLAG_PAYLOAD_LENGTH_FIELD_IS_WORD
00055 
00056 #if (ASF_PPI_FLAG_SEQUENCE_FIELD_IS_BYTE == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_SEQUENCE_FIELD_SIZE))
00057 #   define ASF_PPI_SEQUENCE_FIELD_SIZE 1
00058 #endif
00059 #if (ASF_PPI_FLAG_SEQUENCE_FIELD_IS_WORD == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_SEQUENCE_FIELD_SIZE))
00060 #   define ASF_PPI_SEQUENCE_FIELD_SIZE 2
00061 #endif
00062 #if (ASF_PPI_FLAG_SEQUENCE_FIELD_IS_DWORD == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_SEQUENCE_FIELD_SIZE))
00063 #   define ASF_PPI_SEQUENCE_FIELD_SIZE 4
00064 #endif
00065 #ifndef ASF_PPI_SEQUENCE_FIELD_SIZE
00066 #   define ASF_PPI_SEQUENCE_FIELD_SIZE 0
00067 #endif
00068 
00069 
00070 #if (ASF_PPI_FLAG_PACKET_LENGTH_FIELD_IS_BYTE == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PACKET_LENGTH_FIELD_SIZE))
00071 #   define ASF_PPI_PACKET_LENGTH_FIELD_SIZE 1
00072 #endif
00073 #if (ASF_PPI_FLAG_PACKET_LENGTH_FIELD_IS_WORD == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PACKET_LENGTH_FIELD_SIZE))
00074 #   define ASF_PPI_PACKET_LENGTH_FIELD_SIZE 2
00075 #endif
00076 #if (ASF_PPI_FLAG_PACKET_LENGTH_FIELD_IS_DWORD == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PACKET_LENGTH_FIELD_SIZE))
00077 #   define ASF_PPI_PACKET_LENGTH_FIELD_SIZE 4
00078 #endif
00079 #ifndef ASF_PPI_PACKET_LENGTH_FIELD_SIZE
00080 #   define ASF_PPI_PACKET_LENGTH_FIELD_SIZE 0
00081 #endif
00082 
00083 #if (ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_BYTE == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PADDING_LENGTH_FIELD_SIZE))
00084 #   define ASF_PPI_PADDING_LENGTH_FIELD_SIZE 1
00085 #endif
00086 #if (ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_WORD == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PADDING_LENGTH_FIELD_SIZE))
00087 #   define ASF_PPI_PADDING_LENGTH_FIELD_SIZE 2
00088 #endif
00089 #if (ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_DWORD == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PADDING_LENGTH_FIELD_SIZE))
00090 #   define ASF_PPI_PADDING_LENGTH_FIELD_SIZE 4
00091 #endif
00092 #ifndef ASF_PPI_PADDING_LENGTH_FIELD_SIZE
00093 #   define ASF_PPI_PADDING_LENGTH_FIELD_SIZE 0
00094 #endif
00095 
00096 #if (ASF_PL_FLAG_REPLICATED_DATA_LENGTH_FIELD_IS_BYTE == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_REPLICATED_DATA_LENGTH_FIELD_SIZE))
00097 #   define ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE 1
00098 #endif
00099 #if (ASF_PL_FLAG_REPLICATED_DATA_LENGTH_FIELD_IS_WORD == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_REPLICATED_DATA_LENGTH_FIELD_SIZE))
00100 #   define ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE 2
00101 #endif
00102 #if (ASF_PL_FLAG_REPLICATED_DATA_LENGTH_FIELD_IS_DWORD == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_REPLICATED_DATA_LENGTH_FIELD_SIZE))
00103 #   define ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE 4
00104 #endif
00105 #ifndef ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE
00106 #   define ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE 0
00107 #endif
00108 
00109 #if (ASF_PL_FLAG_OFFSET_INTO_MEDIA_OBJECT_LENGTH_FIELD_IS_BYTE == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_OFFSET_INTO_MEDIA_OBJECT_LENGTH_FIELD_SIZE))
00110 #   define ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE 1
00111 #endif
00112 #if (ASF_PL_FLAG_OFFSET_INTO_MEDIA_OBJECT_LENGTH_FIELD_IS_WORD == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_OFFSET_INTO_MEDIA_OBJECT_LENGTH_FIELD_SIZE))
00113 #   define ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE 2
00114 #endif
00115 #if (ASF_PL_FLAG_OFFSET_INTO_MEDIA_OBJECT_LENGTH_FIELD_IS_DWORD == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_OFFSET_INTO_MEDIA_OBJECT_LENGTH_FIELD_SIZE))
00116 #   define ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE 4
00117 #endif
00118 #ifndef ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE
00119 #   define ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE 0
00120 #endif
00121 
00122 #if (ASF_PL_FLAG_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_IS_BYTE == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_SIZE))
00123 #   define ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE 1
00124 #endif
00125 #if (ASF_PL_FLAG_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_IS_WORD == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_SIZE))
00126 #   define ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE 2
00127 #endif
00128 #if (ASF_PL_FLAG_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_IS_DWORD == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_SIZE))
00129 #   define ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE 4
00130 #endif
00131 #ifndef ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE
00132 #   define ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE 0
00133 #endif
00134 
00135 #if (ASF_PL_FLAG_PAYLOAD_LENGTH_FIELD_IS_BYTE == (ASF_PAYLOAD_FLAGS & ASF_PL_MASK_PAYLOAD_LENGTH_FIELD_SIZE))
00136 #   define ASF_PAYLOAD_LENGTH_FIELD_SIZE 1
00137 #endif
00138 #if (ASF_PL_FLAG_PAYLOAD_LENGTH_FIELD_IS_WORD == (ASF_PAYLOAD_FLAGS & ASF_PL_MASK_PAYLOAD_LENGTH_FIELD_SIZE))
00139 #   define ASF_PAYLOAD_LENGTH_FIELD_SIZE 2
00140 #endif
00141 #ifndef ASF_PAYLOAD_LENGTH_FIELD_SIZE
00142 #   define ASF_PAYLOAD_LENGTH_FIELD_SIZE 0
00143 #endif
00144 
00145 #define PACKET_HEADER_MIN_SIZE (\
00146                 ASF_PACKET_ERROR_CORRECTION_FLAGS_FIELD_SIZE + \
00147                 ASF_PACKET_ERROR_CORRECTION_DATA_SIZE + \
00148                 1 + /*Length Type Flags*/ \
00149                 1 + /*Property Flags*/ \
00150                 ASF_PPI_PACKET_LENGTH_FIELD_SIZE + \
00151                 ASF_PPI_SEQUENCE_FIELD_SIZE + \
00152                 ASF_PPI_PADDING_LENGTH_FIELD_SIZE + \
00153                 4 + /*Send Time Field*/ \
00154                 2   /*Duration Field*/ \
00155                 )
00156 
00157 
00158 // Replicated Data shall be at least 8 bytes long.
00159 #define ASF_PAYLOAD_REPLICATED_DATA_LENGTH 0x08
00160 
00161 #define PAYLOAD_HEADER_SIZE_SINGLE_PAYLOAD (\
00162                 1 + /*Stream Number*/ \
00163                 ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE + \
00164                 ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE + \
00165                 ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE + \
00166                 ASF_PAYLOAD_REPLICATED_DATA_LENGTH \
00167                 )
00168 
00169 #define PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS (\
00170                 1 + /*Stream Number*/ \
00171                 ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE + \
00172                 ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE + \
00173                 ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE + \
00174                 ASF_PAYLOAD_REPLICATED_DATA_LENGTH + \
00175                 ASF_PAYLOAD_LENGTH_FIELD_SIZE \
00176                 )
00177 
00178 #define SINGLE_PAYLOAD_DATA_LENGTH (\
00179                 PACKET_SIZE - \
00180                 PACKET_HEADER_MIN_SIZE - \
00181                 PAYLOAD_HEADER_SIZE_SINGLE_PAYLOAD \
00182                 )
00183 
00184 #define MULTI_PAYLOAD_CONSTANT (\
00185                 PACKET_SIZE - \
00186                 PACKET_HEADER_MIN_SIZE - \
00187                 1 - /*Payload Flags*/ \
00188                 2*PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS \
00189                 )
00190 
00191 static const AVCodecTag codec_asf_bmp_tags[] = {
00192     { CODEC_ID_MPEG4, MKTAG('M', 'P', '4', 'S') },
00193     { CODEC_ID_MPEG4, MKTAG('M', '4', 'S', '2') },
00194     { CODEC_ID_MSMPEG4V3, MKTAG('M', 'P', '4', '3') },
00195     { CODEC_ID_NONE, 0 },
00196 };
00197 
00198 #define PREROLL_TIME 3100
00199 
00200 static void put_guid(ByteIOContext *s, const GUID *g)
00201 {
00202     assert(sizeof(*g) == 16);
00203     put_buffer(s, *g, sizeof(*g));
00204 }
00205 
00206 static void put_str16_nolen(ByteIOContext *s, const char *tag);
00207 static void put_str16(ByteIOContext *s, const char *tag)
00208 {
00209     put_le16(s,strlen(tag) + 1);
00210     put_str16_nolen(s, tag);
00211 }
00212 
00213 static void put_str16_nolen(ByteIOContext *s, const char *tag)
00214 {
00215     int c;
00216 
00217     do{
00218         c = (uint8_t)*tag++;
00219         put_le16(s, c);
00220     }while(c);
00221 }
00222 
00223 static int64_t put_header(ByteIOContext *pb, const GUID *g)
00224 {
00225     int64_t pos;
00226 
00227     pos = url_ftell(pb);
00228     put_guid(pb, g);
00229     put_le64(pb, 24);
00230     return pos;
00231 }
00232 
00233 /* update header size */
00234 static void end_header(ByteIOContext *pb, int64_t pos)
00235 {
00236     int64_t pos1;
00237 
00238     pos1 = url_ftell(pb);
00239     url_fseek(pb, pos + 16, SEEK_SET);
00240     put_le64(pb, pos1 - pos);
00241     url_fseek(pb, pos1, SEEK_SET);
00242 }
00243 
00244 /* write an asf chunk (only used in streaming case) */
00245 static void put_chunk(AVFormatContext *s, int type, int payload_length, int flags)
00246 {
00247     ASFContext *asf = s->priv_data;
00248     ByteIOContext *pb = s->pb;
00249     int length;
00250 
00251     length = payload_length + 8;
00252     put_le16(pb, type);
00253     put_le16(pb, length);    //size
00254     put_le32(pb, asf->seqno);//sequence number
00255     put_le16(pb, flags); /* unknown bytes */
00256     put_le16(pb, length);    //size_confirm
00257     asf->seqno++;
00258 }
00259 
00260 /* convert from unix to windows time */
00261 static int64_t unix_to_file_time(int ti)
00262 {
00263     int64_t t;
00264 
00265     t = ti * INT64_C(10000000);
00266     t += INT64_C(116444736000000000);
00267     return t;
00268 }
00269 
00270 /* write the header (used two times if non streamed) */
00271 static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data_chunk_size)
00272 {
00273     ASFContext *asf = s->priv_data;
00274     ByteIOContext *pb = s->pb;
00275     AVMetadataTag *title, *author, *copyright, *comment;
00276     int header_size, n, extra_size, extra_size2, wav_extra_size, file_time;
00277     int has_title;
00278     int metadata_count;
00279     AVCodecContext *enc;
00280     int64_t header_offset, cur_pos, hpos;
00281     int bit_rate;
00282     int64_t duration;
00283 
00284     title     = av_metadata_get(s->metadata, "title"    , NULL, 0);
00285     author    = av_metadata_get(s->metadata, "author"   , NULL, 0);
00286     copyright = av_metadata_get(s->metadata, "copyright", NULL, 0);
00287     comment   = av_metadata_get(s->metadata, "comment"  , NULL, 0);
00288 
00289     duration = asf->duration + PREROLL_TIME * 10000;
00290     has_title = title || author || copyright || comment;
00291     metadata_count = s->metadata ? s->metadata->count : 0;
00292 
00293     bit_rate = 0;
00294     for(n=0;n<s->nb_streams;n++) {
00295         enc = s->streams[n]->codec;
00296 
00297         av_set_pts_info(s->streams[n], 32, 1, 1000); /* 32 bit pts in ms */
00298 
00299         bit_rate += enc->bit_rate;
00300     }
00301 
00302     if (asf->is_streamed) {
00303         put_chunk(s, 0x4824, 0, 0xc00); /* start of stream (length will be patched later) */
00304     }
00305 
00306     put_guid(pb, &ff_asf_header);
00307     put_le64(pb, -1); /* header length, will be patched after */
00308     put_le32(pb, 3 + has_title + !!metadata_count + s->nb_streams); /* number of chunks in header */
00309     put_byte(pb, 1); /* ??? */
00310     put_byte(pb, 2); /* ??? */
00311 
00312     /* file header */
00313     header_offset = url_ftell(pb);
00314     hpos = put_header(pb, &ff_asf_file_header);
00315     put_guid(pb, &ff_asf_my_guid);
00316     put_le64(pb, file_size);
00317     file_time = 0;
00318     put_le64(pb, unix_to_file_time(file_time));
00319     put_le64(pb, asf->nb_packets); /* number of packets */
00320     put_le64(pb, duration); /* end time stamp (in 100ns units) */
00321     put_le64(pb, asf->duration); /* duration (in 100ns units) */
00322     put_le64(pb, PREROLL_TIME); /* start time stamp */
00323     put_le32(pb, (asf->is_streamed || url_is_streamed(pb)) ? 3 : 2); /* ??? */
00324     put_le32(pb, s->packet_size); /* packet size */
00325     put_le32(pb, s->packet_size); /* packet size */
00326     put_le32(pb, bit_rate); /* Nominal data rate in bps */
00327     end_header(pb, hpos);
00328 
00329     /* unknown headers */
00330     hpos = put_header(pb, &ff_asf_head1_guid);
00331     put_guid(pb, &ff_asf_head2_guid);
00332     put_le32(pb, 6);
00333     put_le16(pb, 0);
00334     end_header(pb, hpos);
00335 
00336     /* title and other infos */
00337     if (has_title) {
00338         hpos = put_header(pb, &ff_asf_comment_header);
00339         put_le16(pb, title     ? 2 * (strlen(title->value    ) + 1) : 0);
00340         put_le16(pb, author    ? 2 * (strlen(author->value   ) + 1) : 0);
00341         put_le16(pb, copyright ? 2 * (strlen(copyright->value) + 1) : 0);
00342         put_le16(pb, comment   ? 2 * (strlen(comment->value  ) + 1) : 0);
00343         put_le16(pb, 0);
00344         if (title    ) put_str16_nolen(pb, title->value    );
00345         if (author   ) put_str16_nolen(pb, author->value   );
00346         if (copyright) put_str16_nolen(pb, copyright->value);
00347         if (comment  ) put_str16_nolen(pb, comment->value  );
00348         end_header(pb, hpos);
00349     }
00350     if (metadata_count) {
00351         AVMetadataTag *tag = NULL;
00352         hpos = put_header(pb, &ff_asf_extended_content_header);
00353         put_le16(pb, metadata_count);
00354         while ((tag = av_metadata_get(s->metadata, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
00355             put_le16(pb, 2*(strlen(tag->key) + 3) + 1);
00356             put_le16(pb, 'W');
00357             put_le16(pb, 'M');
00358             put_le16(pb, '/');
00359             put_str16_nolen(pb, tag->key);
00360             put_le16(pb, 0);
00361             put_le16(pb, 2*strlen(tag->value) + 1);
00362             put_str16_nolen(pb, tag->value);
00363         }
00364         end_header(pb, hpos);
00365     }
00366 
00367     /* stream headers */
00368     for(n=0;n<s->nb_streams;n++) {
00369         int64_t es_pos;
00370         //        ASFStream *stream = &asf->streams[n];
00371 
00372         enc = s->streams[n]->codec;
00373         asf->streams[n].num = n + 1;
00374         asf->streams[n].seq = 0;
00375 
00376 
00377         switch(enc->codec_type) {
00378         case CODEC_TYPE_AUDIO:
00379             wav_extra_size = 0;
00380             extra_size = 18 + wav_extra_size;
00381             extra_size2 = 8;
00382             break;
00383         default:
00384         case CODEC_TYPE_VIDEO:
00385             wav_extra_size = enc->extradata_size;
00386             extra_size = 0x33 + wav_extra_size;
00387             extra_size2 = 0;
00388             break;
00389         }
00390 
00391         hpos = put_header(pb, &ff_asf_stream_header);
00392         if (enc->codec_type == CODEC_TYPE_AUDIO) {
00393             put_guid(pb, &ff_asf_audio_stream);
00394             put_guid(pb, &ff_asf_audio_conceal_spread);
00395         } else {
00396             put_guid(pb, &ff_asf_video_stream);
00397             put_guid(pb, &ff_asf_video_conceal_none);
00398         }
00399         put_le64(pb, 0); /* ??? */
00400         es_pos = url_ftell(pb);
00401         put_le32(pb, extra_size); /* wav header len */
00402         put_le32(pb, extra_size2); /* additional data len */
00403         put_le16(pb, n + 1); /* stream number */
00404         put_le32(pb, 0); /* ??? */
00405 
00406         if (enc->codec_type == CODEC_TYPE_AUDIO) {
00407             /* WAVEFORMATEX header */
00408             int wavsize = put_wav_header(pb, enc);
00409             if ((enc->codec_id != CODEC_ID_MP3) && (enc->codec_id != CODEC_ID_MP2) && (enc->codec_id != CODEC_ID_ADPCM_IMA_WAV) && (enc->extradata_size==0)) {
00410                 wavsize += 2;
00411                 put_le16(pb, 0);
00412             }
00413 
00414             if (wavsize < 0)
00415                 return -1;
00416             if (wavsize != extra_size) {
00417                 cur_pos = url_ftell(pb);
00418                 url_fseek(pb, es_pos, SEEK_SET);
00419                 put_le32(pb, wavsize); /* wav header len */
00420                 url_fseek(pb, cur_pos, SEEK_SET);
00421             }
00422             /* ERROR Correction */
00423             put_byte(pb, 0x01);
00424             if(enc->codec_id == CODEC_ID_ADPCM_G726 || !enc->block_align){
00425                 put_le16(pb, 0x0190);
00426                 put_le16(pb, 0x0190);
00427             }else{
00428                 put_le16(pb, enc->block_align);
00429                 put_le16(pb, enc->block_align);
00430             }
00431             put_le16(pb, 0x01);
00432             put_byte(pb, 0x00);
00433         } else {
00434             put_le32(pb, enc->width);
00435             put_le32(pb, enc->height);
00436             put_byte(pb, 2); /* ??? */
00437             put_le16(pb, 40 + enc->extradata_size); /* size */
00438 
00439             /* BITMAPINFOHEADER header */
00440             put_bmp_header(pb, enc, codec_bmp_tags, 1);
00441         }
00442         end_header(pb, hpos);
00443     }
00444 
00445     /* media comments */
00446 
00447     hpos = put_header(pb, &ff_asf_codec_comment_header);
00448     put_guid(pb, &ff_asf_codec_comment1_header);
00449     put_le32(pb, s->nb_streams);
00450     for(n=0;n<s->nb_streams;n++) {
00451         AVCodec *p;
00452 
00453         enc = s->streams[n]->codec;
00454         p = avcodec_find_encoder(enc->codec_id);
00455 
00456         if(enc->codec_type == CODEC_TYPE_AUDIO)
00457             put_le16(pb, 2);
00458         else if(enc->codec_type == CODEC_TYPE_VIDEO)
00459             put_le16(pb, 1);
00460         else
00461             put_le16(pb, -1);
00462 
00463         if(enc->codec_id == CODEC_ID_WMAV2)
00464             put_str16(pb, "Windows Media Audio V8");
00465         else
00466             put_str16(pb, p ? p->name : enc->codec_name);
00467         put_le16(pb, 0); /* no parameters */
00468 
00469 
00470         /* id */
00471         if (enc->codec_type == CODEC_TYPE_AUDIO) {
00472             put_le16(pb, 2);
00473             put_le16(pb, enc->codec_tag);
00474         } else {
00475             put_le16(pb, 4);
00476             put_le32(pb, enc->codec_tag);
00477         }
00478         if(!enc->codec_tag)
00479             return -1;
00480     }
00481     end_header(pb, hpos);
00482 
00483     /* patch the header size fields */
00484 
00485     cur_pos = url_ftell(pb);
00486     header_size = cur_pos - header_offset;
00487     if (asf->is_streamed) {
00488         header_size += 8 + 30 + 50;
00489 
00490         url_fseek(pb, header_offset - 10 - 30, SEEK_SET);
00491         put_le16(pb, header_size);
00492         url_fseek(pb, header_offset - 2 - 30, SEEK_SET);
00493         put_le16(pb, header_size);
00494 
00495         header_size -= 8 + 30 + 50;
00496     }
00497     header_size += 24 + 6;
00498     url_fseek(pb, header_offset - 14, SEEK_SET);
00499     put_le64(pb, header_size);
00500     url_fseek(pb, cur_pos, SEEK_SET);
00501 
00502     /* movie chunk, followed by packets of packet_size */
00503     asf->data_offset = cur_pos;
00504     put_guid(pb, &ff_asf_data_header);
00505     put_le64(pb, data_chunk_size);
00506     put_guid(pb, &ff_asf_my_guid);
00507     put_le64(pb, asf->nb_packets); /* nb packets */
00508     put_byte(pb, 1); /* ??? */
00509     put_byte(pb, 1); /* ??? */
00510     return 0;
00511 }
00512 
00513 static int asf_write_header(AVFormatContext *s)
00514 {
00515     ASFContext *asf = s->priv_data;
00516 
00517     s->packet_size  = PACKET_SIZE;
00518     asf->nb_packets = 0;
00519 
00520     asf->last_indexed_pts = 0;
00521     asf->index_ptr = av_malloc( sizeof(ASFIndex) * ASF_INDEX_BLOCK );
00522     asf->nb_index_memory_alloc = ASF_INDEX_BLOCK;
00523     asf->nb_index_count = 0;
00524     asf->maximum_packet = 0;
00525 
00526     /* the data-chunk-size has to be 50, which is data_size - asf->data_offset
00527      *  at the moment this function is done. It is needed to use asf as
00528      *  streamable format. */
00529     if (asf_write_header1(s, 0, 50) < 0) {
00530         //av_free(asf);
00531         return -1;
00532     }
00533 
00534     put_flush_packet(s->pb);
00535 
00536     asf->packet_nb_payloads = 0;
00537     asf->packet_timestamp_start = -1;
00538     asf->packet_timestamp_end = -1;
00539     init_put_byte(&asf->pb, asf->packet_buf, s->packet_size, 1,
00540                   NULL, NULL, NULL, NULL);
00541 
00542     return 0;
00543 }
00544 
00545 static int asf_write_stream_header(AVFormatContext *s)
00546 {
00547     ASFContext *asf = s->priv_data;
00548 
00549     asf->is_streamed = 1;
00550 
00551     return asf_write_header(s);
00552 }
00553 
00554 static int put_payload_parsing_info(
00555                                 AVFormatContext *s,
00556                                 unsigned int    sendtime,
00557                                 unsigned int    duration,
00558                                 int             nb_payloads,
00559                                 int             padsize
00560             )
00561 {
00562     ASFContext *asf = s->priv_data;
00563     ByteIOContext *pb = s->pb;
00564     int ppi_size, i;
00565     int64_t start= url_ftell(pb);
00566 
00567     int iLengthTypeFlags = ASF_PPI_LENGTH_TYPE_FLAGS;
00568 
00569     padsize -= PACKET_HEADER_MIN_SIZE;
00570     if(asf->multi_payloads_present)
00571         padsize--;
00572     assert(padsize>=0);
00573 
00574     put_byte(pb, ASF_PACKET_ERROR_CORRECTION_FLAGS);
00575     for (i = 0; i < ASF_PACKET_ERROR_CORRECTION_DATA_SIZE; i++){
00576         put_byte(pb, 0x0);
00577     }
00578 
00579     if (asf->multi_payloads_present)
00580         iLengthTypeFlags |= ASF_PPI_FLAG_MULTIPLE_PAYLOADS_PRESENT;
00581 
00582     if (padsize > 0) {
00583         if (padsize < 256)
00584             iLengthTypeFlags |= ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_BYTE;
00585         else
00586             iLengthTypeFlags |= ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_WORD;
00587     }
00588     put_byte(pb, iLengthTypeFlags);
00589 
00590     put_byte(pb, ASF_PPI_PROPERTY_FLAGS);
00591 
00592     if (iLengthTypeFlags & ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_WORD)
00593         put_le16(pb, padsize - 2);
00594     if (iLengthTypeFlags & ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_BYTE)
00595         put_byte(pb, padsize - 1);
00596 
00597     put_le32(pb, sendtime);
00598     put_le16(pb, duration);
00599     if (asf->multi_payloads_present)
00600         put_byte(pb, nb_payloads | ASF_PAYLOAD_FLAGS);
00601 
00602     ppi_size = url_ftell(pb) - start;
00603 
00604     return ppi_size;
00605 }
00606 
00607 static void flush_packet(AVFormatContext *s)
00608 {
00609     ASFContext *asf = s->priv_data;
00610     int packet_hdr_size, packet_filled_size;
00611 
00612     assert(asf->packet_timestamp_end >= asf->packet_timestamp_start);
00613 
00614     if (asf->is_streamed) {
00615         put_chunk(s, 0x4424, s->packet_size, 0);
00616     }
00617 
00618     packet_hdr_size = put_payload_parsing_info(
00619                             s,
00620                             asf->packet_timestamp_start,
00621                             asf->packet_timestamp_end - asf->packet_timestamp_start,
00622                             asf->packet_nb_payloads,
00623                             asf->packet_size_left
00624                         );
00625 
00626     packet_filled_size = PACKET_SIZE - asf->packet_size_left;
00627     assert(packet_hdr_size <= asf->packet_size_left);
00628     memset(asf->packet_buf + packet_filled_size, 0, asf->packet_size_left);
00629 
00630     put_buffer(s->pb, asf->packet_buf, s->packet_size - packet_hdr_size);
00631 
00632     put_flush_packet(s->pb);
00633     asf->nb_packets++;
00634     asf->packet_nb_payloads = 0;
00635     asf->packet_timestamp_start = -1;
00636     asf->packet_timestamp_end = -1;
00637     init_put_byte(&asf->pb, asf->packet_buf, s->packet_size, 1,
00638                   NULL, NULL, NULL, NULL);
00639 }
00640 
00641 static void put_payload_header(
00642                                 AVFormatContext *s,
00643                                 ASFStream       *stream,
00644                                 int             presentation_time,
00645                                 int             m_obj_size,
00646                                 int             m_obj_offset,
00647                                 int             payload_len,
00648                                 int             flags
00649             )
00650 {
00651     ASFContext *asf = s->priv_data;
00652     ByteIOContext *pb = &asf->pb;
00653     int val;
00654 
00655     val = stream->num;
00656     if (flags & PKT_FLAG_KEY)
00657         val |= ASF_PL_FLAG_KEY_FRAME;
00658     put_byte(pb, val);
00659 
00660     put_byte(pb, stream->seq);  //Media object number
00661     put_le32(pb, m_obj_offset); //Offset Into Media Object
00662 
00663     // Replicated Data shall be at least 8 bytes long.
00664     // The first 4 bytes of data shall contain the
00665     // Size of the Media Object that the payload belongs to.
00666     // The next 4 bytes of data shall contain the
00667     // Presentation Time for the media object that the payload belongs to.
00668     put_byte(pb, ASF_PAYLOAD_REPLICATED_DATA_LENGTH);
00669 
00670     put_le32(pb, m_obj_size);       //Replicated Data - Media Object Size
00671     put_le32(pb, presentation_time);//Replicated Data - Presentation Time
00672 
00673     if (asf->multi_payloads_present){
00674         put_le16(pb, payload_len);   //payload length
00675     }
00676 }
00677 
00678 static void put_frame(
00679                     AVFormatContext *s,
00680                     ASFStream       *stream,
00681                     AVStream        *avst,
00682                     int             timestamp,
00683                     const uint8_t   *buf,
00684                     int             m_obj_size,
00685                     int             flags
00686                 )
00687 {
00688     ASFContext *asf = s->priv_data;
00689     int m_obj_offset, payload_len, frag_len1;
00690 
00691     m_obj_offset = 0;
00692     while (m_obj_offset < m_obj_size) {
00693         payload_len = m_obj_size - m_obj_offset;
00694         if (asf->packet_timestamp_start == -1) {
00695             asf->multi_payloads_present = (payload_len < MULTI_PAYLOAD_CONSTANT);
00696 
00697             asf->packet_size_left = PACKET_SIZE;
00698             if (asf->multi_payloads_present){
00699                 frag_len1 = MULTI_PAYLOAD_CONSTANT - 1;
00700             }
00701             else {
00702                 frag_len1 = SINGLE_PAYLOAD_DATA_LENGTH;
00703             }
00704             asf->packet_timestamp_start = timestamp;
00705         }
00706         else {
00707             // multi payloads
00708             frag_len1 = asf->packet_size_left - PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS - PACKET_HEADER_MIN_SIZE - 1;
00709 
00710             if(frag_len1 < payload_len && avst->codec->codec_type == CODEC_TYPE_AUDIO){
00711                 flush_packet(s);
00712                 continue;
00713             }
00714         }
00715         if (frag_len1 > 0) {
00716             if (payload_len > frag_len1)
00717                 payload_len = frag_len1;
00718             else if (payload_len == (frag_len1 - 1))
00719                 payload_len = frag_len1 - 2;  //additional byte need to put padding length
00720 
00721             put_payload_header(s, stream, timestamp+PREROLL_TIME, m_obj_size, m_obj_offset, payload_len, flags);
00722             put_buffer(&asf->pb, buf, payload_len);
00723 
00724             if (asf->multi_payloads_present)
00725                 asf->packet_size_left -= (payload_len + PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS);
00726             else
00727                 asf->packet_size_left -= (payload_len + PAYLOAD_HEADER_SIZE_SINGLE_PAYLOAD);
00728             asf->packet_timestamp_end = timestamp;
00729 
00730             asf->packet_nb_payloads++;
00731         } else {
00732             payload_len = 0;
00733         }
00734         m_obj_offset += payload_len;
00735         buf += payload_len;
00736 
00737         if (!asf->multi_payloads_present)
00738             flush_packet(s);
00739         else if (asf->packet_size_left <= (PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS + PACKET_HEADER_MIN_SIZE + 1))
00740             flush_packet(s);
00741     }
00742     stream->seq++;
00743 }
00744 
00745 static int asf_write_packet(AVFormatContext *s, AVPacket *pkt)
00746 {
00747     ASFContext *asf = s->priv_data;
00748     ASFStream *stream;
00749     int64_t duration;
00750     AVCodecContext *codec;
00751     int64_t packet_st,pts;
00752     int start_sec,i;
00753     int flags= pkt->flags;
00754 
00755     codec = s->streams[pkt->stream_index]->codec;
00756     stream = &asf->streams[pkt->stream_index];
00757 
00758     if(codec->codec_type == CODEC_TYPE_AUDIO)
00759         flags &= ~PKT_FLAG_KEY;
00760 
00761     pts = (pkt->pts != AV_NOPTS_VALUE) ? pkt->pts : pkt->dts;
00762     assert(pts != AV_NOPTS_VALUE);
00763     duration = pts * 10000;
00764     asf->duration= FFMAX(asf->duration, duration + pkt->duration * 10000);
00765 
00766     packet_st = asf->nb_packets;
00767     put_frame(s, stream, s->streams[pkt->stream_index], pkt->dts, pkt->data, pkt->size, flags);
00768 
00769     /* check index */
00770     if ((!asf->is_streamed) && (flags & PKT_FLAG_KEY)) {
00771         start_sec = (int)(duration / INT64_C(10000000));
00772         if (start_sec != (int)(asf->last_indexed_pts / INT64_C(10000000))) {
00773             for(i=asf->nb_index_count;i<start_sec;i++) {
00774                 if (i>=asf->nb_index_memory_alloc) {
00775                     asf->nb_index_memory_alloc += ASF_INDEX_BLOCK;
00776                     asf->index_ptr = (ASFIndex*)av_realloc( asf->index_ptr, sizeof(ASFIndex) * asf->nb_index_memory_alloc );
00777                 }
00778                 // store
00779                 asf->index_ptr[i].packet_number = (uint32_t)packet_st;
00780                 asf->index_ptr[i].packet_count  = (uint16_t)(asf->nb_packets-packet_st);
00781                 asf->maximum_packet = FFMAX(asf->maximum_packet, (uint16_t)(asf->nb_packets-packet_st));
00782             }
00783             asf->nb_index_count = start_sec;
00784             asf->last_indexed_pts = duration;
00785         }
00786     }
00787     return 0;
00788 }
00789 
00790 //
00791 static int asf_write_index(AVFormatContext *s, ASFIndex *index, uint16_t max, uint32_t count)
00792 {
00793     ByteIOContext *pb = s->pb;
00794     int i;
00795 
00796     put_guid(pb, &ff_asf_simple_index_header);
00797     put_le64(pb, 24 + 16 + 8 + 4 + 4 + (4 + 2)*count);
00798     put_guid(pb, &ff_asf_my_guid);
00799     put_le64(pb, ASF_INDEXED_INTERVAL);
00800     put_le32(pb, max);
00801     put_le32(pb, count);
00802     for(i=0; i<count; i++) {
00803         put_le32(pb, index[i].packet_number);
00804         put_le16(pb, index[i].packet_count);
00805     }
00806 
00807     return 0;
00808 }
00809 
00810 static int asf_write_trailer(AVFormatContext *s)
00811 {
00812     ASFContext *asf = s->priv_data;
00813     int64_t file_size,data_size;
00814 
00815     /* flush the current packet */
00816     if (asf->pb.buf_ptr > asf->pb.buffer)
00817         flush_packet(s);
00818 
00819     /* write index */
00820     data_size = url_ftell(s->pb);
00821     if ((!asf->is_streamed) && (asf->nb_index_count != 0)) {
00822         asf_write_index(s, asf->index_ptr, asf->maximum_packet, asf->nb_index_count);
00823     }
00824     put_flush_packet(s->pb);
00825 
00826     if (asf->is_streamed || url_is_streamed(s->pb)) {
00827         put_chunk(s, 0x4524, 0, 0); /* end of stream */
00828     } else {
00829         /* rewrite an updated header */
00830         file_size = url_ftell(s->pb);
00831         url_fseek(s->pb, 0, SEEK_SET);
00832         asf_write_header1(s, file_size, data_size - asf->data_offset);
00833     }
00834 
00835     put_flush_packet(s->pb);
00836     av_free(asf->index_ptr);
00837     return 0;
00838 }
00839 
00840 #if CONFIG_ASF_MUXER
00841 AVOutputFormat asf_muxer = {
00842     "asf",
00843     NULL_IF_CONFIG_SMALL("ASF format"),
00844     "video/x-ms-asf",
00845     "asf,wmv,wma",
00846     sizeof(ASFContext),
00847 #if CONFIG_LIBMP3LAME
00848     CODEC_ID_MP3,
00849 #else
00850     CODEC_ID_MP2,
00851 #endif
00852     CODEC_ID_MSMPEG4V3,
00853     asf_write_header,
00854     asf_write_packet,
00855     asf_write_trailer,
00856     .flags = AVFMT_GLOBALHEADER,
00857     .codec_tag= (const AVCodecTag* const []){codec_asf_bmp_tags, codec_bmp_tags, codec_wav_tags, 0},
00858     .metadata_conv = ff_asf_metadata_conv,
00859 };
00860 #endif
00861 
00862 #if CONFIG_ASF_STREAM_MUXER
00863 AVOutputFormat asf_stream_muxer = {
00864     "asf_stream",
00865     NULL_IF_CONFIG_SMALL("ASF format"),
00866     "video/x-ms-asf",
00867     "asf,wmv,wma",
00868     sizeof(ASFContext),
00869 #if CONFIG_LIBMP3LAME
00870     CODEC_ID_MP3,
00871 #else
00872     CODEC_ID_MP2,
00873 #endif
00874     CODEC_ID_MSMPEG4V3,
00875     asf_write_stream_header,
00876     asf_write_packet,
00877     asf_write_trailer,
00878     .flags = AVFMT_GLOBALHEADER,
00879     .codec_tag= (const AVCodecTag* const []){codec_asf_bmp_tags, codec_bmp_tags, codec_wav_tags, 0},
00880     .metadata_conv = ff_asf_metadata_conv,
00881 };
00882 #endif //CONFIG_ASF_STREAM_MUXER

Generated on Tue Nov 4 2014 12:59:23 for ffmpeg by  doxygen 1.7.1