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.
8293 Commits
32 Branches
283MB
Tree: 928e00948a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '928e00948a'
${ noResults }
FFmpeg/libavformat/asf-enc.c

839 lines
28KB
Raw Blame History 

  1. /*

  2.  * Adaptive stream format muxer

  3.  * Copyright (c) 2000, 2001 Fabrice Bellard.

  4.  *

  5.  * This file is part of FFmpeg.

  6.  *

  7.  * FFmpeg is free software; you can redistribute it and/or

  8.  * modify it under the terms of the GNU Lesser General Public

  9.  * License as published by the Free Software Foundation; either

  10.  * version 2.1 of the License, or (at your option) any later version.

  11.  *

  12.  * FFmpeg is distributed in the hope that it will be useful,

  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  15.  * Lesser General Public License for more details.

  16.  *

  17.  * You should have received a copy of the GNU Lesser General Public

  18.  * License along with FFmpeg; if not, write to the Free Software

  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  20.  */

  21. #include "avformat.h"

  22. #include "riff.h"

  23. #include "asf.h"

  24. 

  25. #undef NDEBUG

  26. #include <assert.h>

  27. 

  28. 

  29. #define ASF_INDEXED_INTERVAL    10000000

  30. #define ASF_INDEX_BLOCK         600

  31. 

  32. #define ASF_PACKET_ERROR_CORRECTION_DATA_SIZE 0x2

  33. #define ASF_PACKET_ERROR_CORRECTION_FLAGS (\

  34.                 ASF_PACKET_FLAG_ERROR_CORRECTION_PRESENT | \

  35.                 ASF_PACKET_ERROR_CORRECTION_DATA_SIZE\

  36.                 )

  37. 

  38. #if (ASF_PACKET_ERROR_CORRECTION_FLAGS != 0)

  39. #   define ASF_PACKET_ERROR_CORRECTION_FLAGS_FIELD_SIZE 1

  40. #else

  41. #   define ASF_PACKET_ERROR_CORRECTION_FLAGS_FIELD_SIZE 0

  42. #endif

  43. 

  44. #define ASF_PPI_PROPERTY_FLAGS (\

  45.                 ASF_PL_FLAG_REPLICATED_DATA_LENGTH_FIELD_IS_BYTE | \

  46.                 ASF_PL_FLAG_OFFSET_INTO_MEDIA_OBJECT_LENGTH_FIELD_IS_DWORD | \

  47.                 ASF_PL_FLAG_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_IS_BYTE | \

  48.                 ASF_PL_FLAG_STREAM_NUMBER_LENGTH_FIELD_IS_BYTE \

  49.                 )

  50. 

  51. #define ASF_PPI_LENGTH_TYPE_FLAGS 0

  52. 

  53. #define ASF_PAYLOAD_FLAGS ASF_PL_FLAG_PAYLOAD_LENGTH_FIELD_IS_WORD

  54. 

  55. #if (ASF_PPI_FLAG_SEQUENCE_FIELD_IS_BYTE == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_SEQUENCE_FIELD_SIZE))

  56. #   define ASF_PPI_SEQUENCE_FIELD_SIZE 1

  57. #endif

  58. #if (ASF_PPI_FLAG_SEQUENCE_FIELD_IS_WORD == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_SEQUENCE_FIELD_SIZE))

  59. #   define ASF_PPI_SEQUENCE_FIELD_SIZE 2

  60. #endif

  61. #if (ASF_PPI_FLAG_SEQUENCE_FIELD_IS_DWORD == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_SEQUENCE_FIELD_SIZE))

  62. #   define ASF_PPI_SEQUENCE_FIELD_SIZE 4

  63. #endif

  64. #ifndef ASF_PPI_SEQUENCE_FIELD_SIZE

  65. #   define ASF_PPI_SEQUENCE_FIELD_SIZE 0

  66. #endif

  67. 

  68. 

  69. #if (ASF_PPI_FLAG_PACKET_LENGTH_FIELD_IS_BYTE == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PACKET_LENGTH_FIELD_SIZE))

  70. #   define ASF_PPI_PACKET_LENGTH_FIELD_SIZE 1

  71. #endif

  72. #if (ASF_PPI_FLAG_PACKET_LENGTH_FIELD_IS_WORD == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PACKET_LENGTH_FIELD_SIZE))

  73. #   define ASF_PPI_PACKET_LENGTH_FIELD_SIZE 2

  74. #endif

  75. #if (ASF_PPI_FLAG_PACKET_LENGTH_FIELD_IS_DWORD == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PACKET_LENGTH_FIELD_SIZE))

  76. #   define ASF_PPI_PACKET_LENGTH_FIELD_SIZE 4

  77. #endif

  78. #ifndef ASF_PPI_PACKET_LENGTH_FIELD_SIZE

  79. #   define ASF_PPI_PACKET_LENGTH_FIELD_SIZE 0

  80. #endif

  81. 

  82. #if (ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_BYTE == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PADDING_LENGTH_FIELD_SIZE))

  83. #   define ASF_PPI_PADDING_LENGTH_FIELD_SIZE 1

  84. #endif

  85. #if (ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_WORD == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PADDING_LENGTH_FIELD_SIZE))

  86. #   define ASF_PPI_PADDING_LENGTH_FIELD_SIZE 2

  87. #endif

  88. #if (ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_DWORD == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PADDING_LENGTH_FIELD_SIZE))

  89. #   define ASF_PPI_PADDING_LENGTH_FIELD_SIZE 4

  90. #endif

  91. #ifndef ASF_PPI_PADDING_LENGTH_FIELD_SIZE

  92. #   define ASF_PPI_PADDING_LENGTH_FIELD_SIZE 0

  93. #endif

  94. 

  95. #if (ASF_PL_FLAG_REPLICATED_DATA_LENGTH_FIELD_IS_BYTE == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_REPLICATED_DATA_LENGTH_FIELD_SIZE))

  96. #   define ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE 1

  97. #endif

  98. #if (ASF_PL_FLAG_REPLICATED_DATA_LENGTH_FIELD_IS_WORD == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_REPLICATED_DATA_LENGTH_FIELD_SIZE))

  99. #   define ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE 2

  100. #endif

  101. #if (ASF_PL_FLAG_REPLICATED_DATA_LENGTH_FIELD_IS_DWORD == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_REPLICATED_DATA_LENGTH_FIELD_SIZE))

  102. #   define ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE 4

  103. #endif

  104. #ifndef ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE

  105. #   define ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE 0

  106. #endif

  107. 

  108. #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))

  109. #   define ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE 1

  110. #endif

  111. #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))

  112. #   define ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE 2

  113. #endif

  114. #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))

  115. #   define ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE 4

  116. #endif

  117. #ifndef ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE

  118. #   define ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE 0

  119. #endif

  120. 

  121. #if (ASF_PL_FLAG_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_IS_BYTE == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_SIZE))

  122. #   define ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE 1

  123. #endif

  124. #if (ASF_PL_FLAG_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_IS_WORD == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_SIZE))

  125. #   define ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE 2

  126. #endif

  127. #if (ASF_PL_FLAG_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_IS_DWORD == (ASF_PPI_PROPERTY_FLAGS & ASF_PL_MASK_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_SIZE))

  128. #   define ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE 4

  129. #endif

  130. #ifndef ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE

  131. #   define ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE 0

  132. #endif

  133. 

  134. #if (ASF_PL_FLAG_PAYLOAD_LENGTH_FIELD_IS_BYTE == (ASF_PAYLOAD_FLAGS & ASF_PL_MASK_PAYLOAD_LENGTH_FIELD_SIZE))

  135. #   define ASF_PAYLOAD_LENGTH_FIELD_SIZE 1

  136. #endif

  137. #if (ASF_PL_FLAG_PAYLOAD_LENGTH_FIELD_IS_WORD == (ASF_PAYLOAD_FLAGS & ASF_PL_MASK_PAYLOAD_LENGTH_FIELD_SIZE))

  138. #   define ASF_PAYLOAD_LENGTH_FIELD_SIZE 2

  139. #endif

  140. #ifndef ASF_PAYLOAD_LENGTH_FIELD_SIZE

  141. #   define ASF_PAYLOAD_LENGTH_FIELD_SIZE 0

  142. #endif

  143. 

  144. #define PACKET_HEADER_MIN_SIZE (\

  145.                 ASF_PACKET_ERROR_CORRECTION_FLAGS_FIELD_SIZE + \

  146.                 ASF_PACKET_ERROR_CORRECTION_DATA_SIZE + \

  147.                 1 + /*Length Type Flags*/ \

  148.                 1 + /*Property Flags*/ \

  149.                 ASF_PPI_PACKET_LENGTH_FIELD_SIZE + \

  150.                 ASF_PPI_SEQUENCE_FIELD_SIZE + \

  151.                 ASF_PPI_PADDING_LENGTH_FIELD_SIZE + \

  152.                 4 + /*Send Time Field*/ \

  153.                 2   /*Duration Field*/ \

  154.                 )

  155. 

  156. 

  157. // Replicated Data shall be at least 8 bytes long.

  158. #define ASF_PAYLOAD_REPLICATED_DATA_LENGTH 0x08

  159. 

  160. #define PAYLOAD_HEADER_SIZE_SINGLE_PAYLOAD (\

  161.                 1 + /*Stream Number*/ \

  162.                 ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE + \

  163.                 ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE + \

  164.                 ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE + \

  165.                 ASF_PAYLOAD_REPLICATED_DATA_LENGTH \

  166.                 )

  167. 

  168. #define PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS (\

  169.                 1 + /*Stream Number*/ \

  170.                 ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE + \

  171.                 ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE + \

  172.                 ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE + \

  173.                 ASF_PAYLOAD_REPLICATED_DATA_LENGTH + \

  174.                 ASF_PAYLOAD_LENGTH_FIELD_SIZE \

  175.                 )

  176. 

  177. #define SINGLE_PAYLOAD_DATA_LENGTH (\

  178.                 PACKET_SIZE - \

  179.                 PACKET_HEADER_MIN_SIZE - \

  180.                 PAYLOAD_HEADER_SIZE_SINGLE_PAYLOAD \

  181.                 )

  182. 

  183. #define MULTI_PAYLOAD_CONSTANT (\

  184.                 PACKET_SIZE - \

  185.                 PACKET_HEADER_MIN_SIZE - \

  186.                 1 - /*Payload Flags*/ \

  187.                 2*PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS \

  188.                 )

  189. 

  190. static const AVCodecTag codec_asf_bmp_tags[] = {

  191.     { CODEC_ID_MPEG4, MKTAG('M', 'P', '4', 'S') },

  192.     { CODEC_ID_MPEG4, MKTAG('M', '4', 'S', '2') },

  193.     { CODEC_ID_MSMPEG4V3, MKTAG('M', 'P', '4', '3') },

  194.     { CODEC_ID_NONE, 0 },

  195. };

  196. 

  197. static int preroll_time = 2000;

  198. 

  199. static const uint8_t error_spread_ADPCM_G726[] = { 0x01, 0x90, 0x01, 0x90, 0x01, 0x01, 0x00, 0x00 };

  200. 

  201. static void put_guid(ByteIOContext *s, const GUID *g)

  202. {

  203.     assert(sizeof(*g) == 16);

  204.     put_buffer(s, g, sizeof(*g));

  205. }

  206. 

  207. static void put_str16_nolen(ByteIOContext *s, const char *tag);

  208. static void put_str16(ByteIOContext *s, const char *tag)

  209. {

  210.     put_le16(s,strlen(tag) + 1);

  211.     put_str16_nolen(s, tag);

  212. }

  213. 

  214. static void put_str16_nolen(ByteIOContext *s, const char *tag)

  215. {

  216.     int c;

  217. 

  218.     do{

  219.         c = (uint8_t)*tag++;

  220.         put_le16(s, c);

  221.     }while(c);

  222. }

  223. 

  224. static int64_t put_header(ByteIOContext *pb, const GUID *g)

  225. {

  226.     int64_t pos;

  227. 

  228.     pos = url_ftell(pb);

  229.     put_guid(pb, g);

  230.     put_le64(pb, 24);

  231.     return pos;

  232. }

  233. 

  234. /* update header size */

  235. static void end_header(ByteIOContext *pb, int64_t pos)

  236. {

  237.     int64_t pos1;

  238. 

  239.     pos1 = url_ftell(pb);

  240.     url_fseek(pb, pos + 16, SEEK_SET);

  241.     put_le64(pb, pos1 - pos);

  242.     url_fseek(pb, pos1, SEEK_SET);

  243. }

  244. 

  245. /* write an asf chunk (only used in streaming case) */

  246. static void put_chunk(AVFormatContext *s, int type, int payload_length, int flags)

  247. {

  248.     ASFContext *asf = s->priv_data;

  249.     ByteIOContext *pb = &s->pb;

  250.     int length;

  251. 

  252.     length = payload_length + 8;

  253.     put_le16(pb, type);

  254.     put_le16(pb, length);    //size

  255.     put_le32(pb, asf->seqno);//sequence number

  256.     put_le16(pb, flags); /* unknown bytes */

  257.     put_le16(pb, length);    //size_confirm

  258.     asf->seqno++;

  259. }

  260. 

  261. /* convert from unix to windows time */

  262. static int64_t unix_to_file_time(int ti)

  263. {

  264.     int64_t t;

  265. 

  266.     t = ti * INT64_C(10000000);

  267.     t += INT64_C(116444736000000000);

  268.     return t;

  269. }

  270. 

  271. /* write the header (used two times if non streamed) */

  272. static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data_chunk_size)

  273. {

  274.     ASFContext *asf = s->priv_data;

  275.     ByteIOContext *pb = &s->pb;

  276.     int header_size, n, extra_size, extra_size2, wav_extra_size, file_time;

  277.     int has_title;

  278.     AVCodecContext *enc;

  279.     int64_t header_offset, cur_pos, hpos;

  280.     int bit_rate;

  281.     int64_t duration;

  282. 

  283.     duration = asf->duration + preroll_time * 10000;

  284.     has_title = (s->title[0] || s->author[0] || s->copyright[0] || s->comment[0]);

  285. 

  286.     bit_rate = 0;

  287.     for(n=0;n<s->nb_streams;n++) {

  288.         enc = s->streams[n]->codec;

  289. 

  290.         av_set_pts_info(s->streams[n], 32, 1, 1000); /* 32 bit pts in ms */

  291. 

  292.         bit_rate += enc->bit_rate;

  293.     }

  294. 

  295.     if (asf->is_streamed) {

  296.         put_chunk(s, 0x4824, 0, 0xc00); /* start of stream (length will be patched later) */

  297.     }

  298. 

  299.     put_guid(pb, &asf_header);

  300.     put_le64(pb, -1); /* header length, will be patched after */

  301.     put_le32(pb, 3 + has_title + s->nb_streams); /* number of chunks in header */

  302.     put_byte(pb, 1); /* ??? */

  303.     put_byte(pb, 2); /* ??? */

  304. 

  305.     /* file header */

  306.     header_offset = url_ftell(pb);

  307.     hpos = put_header(pb, &file_header);

  308.     put_guid(pb, &my_guid);

  309.     put_le64(pb, file_size);

  310.     file_time = 0;

  311.     put_le64(pb, unix_to_file_time(file_time));

  312.     put_le64(pb, asf->nb_packets); /* number of packets */

  313.     put_le64(pb, duration); /* end time stamp (in 100ns units) */

  314.     put_le64(pb, duration); /* duration (in 100ns units) */

  315.     put_le32(pb, preroll_time); /* start time stamp */

  316.     put_le32(pb, 0); /* ??? */

  317.     put_le32(pb, asf->is_streamed ? 1 : 0); /* ??? */

  318.     put_le32(pb, asf->packet_size); /* packet size */

  319.     put_le32(pb, asf->packet_size); /* packet size */

  320.     put_le32(pb, bit_rate); /* Nominal data rate in bps */

  321.     end_header(pb, hpos);

  322. 

  323.     /* unknown headers */

  324.     hpos = put_header(pb, &head1_guid);

  325.     put_guid(pb, &head2_guid);

  326.     put_le32(pb, 6);

  327.     put_le16(pb, 0);

  328.     end_header(pb, hpos);

  329. 

  330.     /* title and other infos */

  331.     if (has_title) {

  332.         hpos = put_header(pb, &comment_header);

  333.         if ( s->title[0]     ) { put_le16(pb, 2 * (strlen(s->title    ) + 1)); } else { put_le16(pb, 0); }

  334.         if ( s->author[0]    ) { put_le16(pb, 2 * (strlen(s->author   ) + 1)); } else { put_le16(pb, 0); }

  335.         if ( s->copyright[0] ) { put_le16(pb, 2 * (strlen(s->copyright) + 1)); } else { put_le16(pb, 0); }

  336.         if ( s->comment[0]   ) { put_le16(pb, 2 * (strlen(s->comment  ) + 1)); } else { put_le16(pb, 0); }

  337.         put_le16(pb, 0);

  338.         if ( s->title[0]     ) put_str16_nolen(pb, s->title);

  339.         if ( s->author[0]    ) put_str16_nolen(pb, s->author);

  340.         if ( s->copyright[0] ) put_str16_nolen(pb, s->copyright);

  341.         if ( s->comment[0]   ) put_str16_nolen(pb, s->comment);

  342.         end_header(pb, hpos);

  343.     }

  344. 

  345.     /* stream headers */

  346.     for(n=0;n<s->nb_streams;n++) {

  347.         int64_t es_pos;

  348.         const uint8_t *er_spr = NULL;

  349.         int er_spr_len = 0;

  350.         //        ASFStream *stream = &asf->streams[n];

  351. 

  352.         enc = s->streams[n]->codec;

  353.         asf->streams[n].num = n + 1;

  354.         asf->streams[n].seq = 0;

  355. 

  356. 

  357.         if (enc->codec_type == CODEC_TYPE_AUDIO) {

  358.             if (enc->codec_id == CODEC_ID_ADPCM_G726) {

  359.                 er_spr     = error_spread_ADPCM_G726;

  360.                 er_spr_len = sizeof(error_spread_ADPCM_G726);

  361.             }

  362.         }

  363. 

  364.         switch(enc->codec_type) {

  365.         case CODEC_TYPE_AUDIO:

  366.             wav_extra_size = 0;

  367.             extra_size = 18 + wav_extra_size;

  368.             extra_size2 = er_spr_len;

  369.             break;

  370.         default:

  371.         case CODEC_TYPE_VIDEO:

  372.             wav_extra_size = enc->extradata_size;

  373.             extra_size = 0x33 + wav_extra_size;

  374.             extra_size2 = 0;

  375.             break;

  376.         }

  377. 

  378.         hpos = put_header(pb, &stream_header);

  379.         if (enc->codec_type == CODEC_TYPE_AUDIO) {

  380.             put_guid(pb, &audio_stream);

  381.             if ((er_spr != NULL) && (er_spr_len != 0)) {

  382.                 put_guid(pb, &audio_conceal_spread);

  383.             } else {

  384.                 put_guid(pb, &video_conceal_none);

  385.             }

  386.         } else {

  387.             put_guid(pb, &video_stream);

  388.             put_guid(pb, &video_conceal_none);

  389.         }

  390.         put_le64(pb, 0); /* ??? */

  391.         es_pos = url_ftell(pb);

  392.         put_le32(pb, extra_size); /* wav header len */

  393.         put_le32(pb, extra_size2); /* additional data len */

  394.         put_le16(pb, n + 1); /* stream number */

  395.         put_le32(pb, 0); /* ??? */

  396. 

  397.         if (enc->codec_type == CODEC_TYPE_AUDIO) {

  398.             /* WAVEFORMATEX header */

  399.             int wavsize = put_wav_header(pb, enc);

  400.             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)) {

  401.                 wavsize += 2;

  402.                 put_le16(pb, 0);

  403.             }

  404. 

  405.             if (wavsize < 0)

  406.                 return -1;

  407.             if (wavsize != extra_size) {

  408.                 cur_pos = url_ftell(pb);

  409.                 url_fseek(pb, es_pos, SEEK_SET);

  410.                 put_le32(pb, wavsize); /* wav header len */

  411.                 url_fseek(pb, cur_pos, SEEK_SET);

  412.             }

  413.             /* ERROR Correction */

  414.             if ((er_spr != NULL) && (er_spr_len != 0))

  415.                 put_buffer(pb, er_spr, er_spr_len);

  416.         } else {

  417.             put_le32(pb, enc->width);

  418.             put_le32(pb, enc->height);

  419.             put_byte(pb, 2); /* ??? */

  420.             put_le16(pb, 40 + enc->extradata_size); /* size */

  421. 

  422.             /* BITMAPINFOHEADER header */

  423.             put_bmp_header(pb, enc, codec_bmp_tags, 1);

  424.         }

  425.         end_header(pb, hpos);

  426.     }

  427. 

  428.     /* media comments */

  429. 

  430.     hpos = put_header(pb, &codec_comment_header);

  431.     put_guid(pb, &codec_comment1_header);

  432.     put_le32(pb, s->nb_streams);

  433.     for(n=0;n<s->nb_streams;n++) {

  434.         AVCodec *p;

  435. 

  436.         enc = s->streams[n]->codec;

  437.         p = avcodec_find_encoder(enc->codec_id);

  438. 

  439.         put_le16(pb, asf->streams[n].num);

  440.         put_str16(pb, p ? p->name : enc->codec_name);

  441.         put_le16(pb, 0); /* no parameters */

  442. 

  443. 

  444.         /* id */

  445.         if (enc->codec_type == CODEC_TYPE_AUDIO) {

  446.             put_le16(pb, 2);

  447.             put_le16(pb, enc->codec_tag);

  448.         } else {

  449.             put_le16(pb, 4);

  450.             put_le32(pb, enc->codec_tag);

  451.         }

  452.         if(!enc->codec_tag)

  453.             return -1;

  454.     }

  455.     end_header(pb, hpos);

  456. 

  457.     /* patch the header size fields */

  458. 

  459.     cur_pos = url_ftell(pb);

  460.     header_size = cur_pos - header_offset;

  461.     if (asf->is_streamed) {

  462.         header_size += 8 + 30 + 50;

  463. 

  464.         url_fseek(pb, header_offset - 10 - 30, SEEK_SET);

  465.         put_le16(pb, header_size);

  466.         url_fseek(pb, header_offset - 2 - 30, SEEK_SET);

  467.         put_le16(pb, header_size);

  468. 

  469.         header_size -= 8 + 30 + 50;

  470.     }

  471.     header_size += 24 + 6;

  472.     url_fseek(pb, header_offset - 14, SEEK_SET);

  473.     put_le64(pb, header_size);

  474.     url_fseek(pb, cur_pos, SEEK_SET);

  475. 

  476.     /* movie chunk, followed by packets of packet_size */

  477.     asf->data_offset = cur_pos;

  478.     put_guid(pb, &data_header);

  479.     put_le64(pb, data_chunk_size);

  480.     put_guid(pb, &my_guid);

  481.     put_le64(pb, asf->nb_packets); /* nb packets */

  482.     put_byte(pb, 1); /* ??? */

  483.     put_byte(pb, 1); /* ??? */

  484.     return 0;

  485. }

  486. 

  487. static int asf_write_header(AVFormatContext *s)

  488. {

  489.     ASFContext *asf = s->priv_data;

  490. 

  491.     asf->packet_size = PACKET_SIZE;

  492.     asf->nb_packets = 0;

  493. 

  494.     asf->last_indexed_pts = 0;

  495.     asf->index_ptr = (ASFIndex*)av_malloc( sizeof(ASFIndex) * ASF_INDEX_BLOCK );

  496.     asf->nb_index_memory_alloc = ASF_INDEX_BLOCK;

  497.     asf->nb_index_count = 0;

  498.     asf->maximum_packet = 0;

  499. 

  500.     if (asf_write_header1(s, 0, 50) < 0) {

  501.         //av_free(asf);

  502.         return -1;

  503.     }

  504. 

  505.     put_flush_packet(&s->pb);

  506. 

  507.     asf->packet_nb_payloads = 0;

  508.     asf->packet_timestamp_start = -1;

  509.     asf->packet_timestamp_end = -1;

  510.     init_put_byte(&asf->pb, asf->packet_buf, asf->packet_size, 1,

  511.                   NULL, NULL, NULL, NULL);

  512. 

  513.     return 0;

  514. }

  515. 

  516. static int asf_write_stream_header(AVFormatContext *s)

  517. {

  518.     ASFContext *asf = s->priv_data;

  519. 

  520.     asf->is_streamed = 1;

  521. 

  522.     return asf_write_header(s);

  523. }

  524. 

  525. static int put_payload_parsing_info(

  526.                                 AVFormatContext *s,

  527.                                 unsigned int    sendtime,

  528.                                 unsigned int    duration,

  529.                                 int             nb_payloads,

  530.                                 int             padsize

  531.             )

  532. {

  533.     ASFContext *asf = s->priv_data;

  534.     ByteIOContext *pb = &s->pb;

  535.     int ppi_size, i;

  536.     int64_t start= url_ftell(pb);

  537. 

  538.     int iLengthTypeFlags = ASF_PPI_LENGTH_TYPE_FLAGS;

  539. 

  540.     put_byte(pb, ASF_PACKET_ERROR_CORRECTION_FLAGS);

  541.     for (i = 0; i < ASF_PACKET_ERROR_CORRECTION_DATA_SIZE; i++){

  542.         put_byte(pb, 0x0);

  543.     }

  544. 

  545.     if (asf->multi_payloads_present)

  546.         iLengthTypeFlags |= ASF_PPI_FLAG_MULTIPLE_PAYLOADS_PRESENT;

  547. 

  548.     if (padsize > 0) {

  549.         if (padsize < 256)

  550.             iLengthTypeFlags |= ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_BYTE;

  551.         else

  552.             iLengthTypeFlags |= ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_WORD;

  553.     }

  554.     put_byte(pb, iLengthTypeFlags);

  555. 

  556.     put_byte(pb, ASF_PPI_PROPERTY_FLAGS);

  557. 

  558.     if (iLengthTypeFlags & ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_WORD)

  559.         put_le16(pb, padsize - 2);

  560.     if (iLengthTypeFlags & ASF_PPI_FLAG_PADDING_LENGTH_FIELD_IS_BYTE)

  561.         put_byte(pb, padsize - 1);

  562. 

  563.     put_le32(pb, sendtime);

  564.     put_le16(pb, duration);

  565.     if (asf->multi_payloads_present)

  566.         put_byte(pb, nb_payloads | ASF_PAYLOAD_FLAGS);

  567. 

  568.     ppi_size = url_ftell(pb) - start;

  569. 

  570.     return ppi_size;

  571. }

  572. 

  573. static void flush_packet(AVFormatContext *s)

  574. {

  575.     ASFContext *asf = s->priv_data;

  576.     int packet_hdr_size, packet_filled_size;

  577. 

  578.     if (asf->is_streamed) {

  579.         put_chunk(s, 0x4424, asf->packet_size, 0);

  580.     }

  581. 

  582.     packet_hdr_size = put_payload_parsing_info(

  583.                             s,

  584.                             asf->packet_timestamp_start,

  585.                             asf->packet_timestamp_end - asf->packet_timestamp_start,

  586.                             asf->packet_nb_payloads,

  587.                             asf->packet_size_left

  588.                         );

  589. 

  590.     packet_filled_size = PACKET_SIZE - packet_hdr_size - asf->packet_size_left;

  591.     memset(asf->packet_buf + packet_filled_size, 0, asf->packet_size_left);

  592. 

  593.     put_buffer(&s->pb, asf->packet_buf, asf->packet_size - packet_hdr_size);

  594. 

  595.     put_flush_packet(&s->pb);

  596.     asf->nb_packets++;

  597.     asf->packet_nb_payloads = 0;

  598.     asf->packet_timestamp_start = -1;

  599.     asf->packet_timestamp_end = -1;

  600.     init_put_byte(&asf->pb, asf->packet_buf, asf->packet_size, 1,

  601.                   NULL, NULL, NULL, NULL);

  602. }

  603. 

  604. static void put_payload_header(

  605.                                 AVFormatContext *s,

  606.                                 ASFStream       *stream,

  607.                                 int             presentation_time,

  608.                                 int             m_obj_size,

  609.                                 int             m_obj_offset,

  610.                                 int             payload_len,

  611.                                 int             flags

  612.             )

  613. {

  614.     ASFContext *asf = s->priv_data;

  615.     ByteIOContext *pb = &asf->pb;

  616.     int val;

  617. 

  618.     val = stream->num;

  619.     if (flags & PKT_FLAG_KEY)

  620.         val |= ASF_PL_FLAG_KEY_FRAME;

  621.     put_byte(pb, val);

  622. 

  623.     put_byte(pb, stream->seq);  //Media object number

  624.     put_le32(pb, m_obj_offset); //Offset Into Media Object

  625. 

  626.     // Replicated Data shall be at least 8 bytes long.

  627.     // The first 4 bytes of data shall contain the

  628.     // Size of the Media Object that the payload belongs to.

  629.     // The next 4 bytes of data shall contain the

  630.     // Presentation Time for the media object that the payload belongs to.

  631.     put_byte(pb, ASF_PAYLOAD_REPLICATED_DATA_LENGTH);

  632. 

  633.     put_le32(pb, m_obj_size);       //Replicated Data - Media Object Size

  634.     put_le32(pb, presentation_time);//Replicated Data - Presentation Time

  635. 

  636.     if (asf->multi_payloads_present){

  637.         put_le16(pb, payload_len);   //payload length

  638.     }

  639. }

  640. 

  641. static void put_frame(

  642.                     AVFormatContext *s,

  643.                     ASFStream       *stream,

  644.                     int             timestamp,

  645.                     const uint8_t   *buf,

  646.                     int             m_obj_size,

  647.                     int             flags

  648.                 )

  649. {

  650.     ASFContext *asf = s->priv_data;

  651.     int m_obj_offset, payload_len, frag_len1;

  652. 

  653.     m_obj_offset = 0;

  654.     while (m_obj_offset < m_obj_size) {

  655.         payload_len = m_obj_size - m_obj_offset;

  656.         if (asf->packet_timestamp_start == -1) {

  657.             asf->multi_payloads_present = (payload_len < MULTI_PAYLOAD_CONSTANT);

  658. 

  659.             if (asf->multi_payloads_present){

  660.                 asf->packet_size_left = PACKET_SIZE; //For debug

  661.                 asf->packet_size_left = PACKET_SIZE - PACKET_HEADER_MIN_SIZE - 1;

  662.                 frag_len1 = MULTI_PAYLOAD_CONSTANT - 1;

  663.             }

  664.             else {

  665.                 asf->packet_size_left = PACKET_SIZE - PACKET_HEADER_MIN_SIZE;

  666.                 frag_len1 = SINGLE_PAYLOAD_DATA_LENGTH;

  667.             }

  668.             asf->packet_timestamp_start = timestamp;

  669.         }

  670.         else {

  671.             // multi payloads

  672.             frag_len1 = asf->packet_size_left - PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS;

  673. 

  674.             asf->packet_timestamp_start = timestamp;

  675.         }

  676.         if (frag_len1 > 0) {

  677.             if (payload_len > frag_len1)

  678.                 payload_len = frag_len1;

  679.             else if (payload_len == (frag_len1 - 1))

  680.                 payload_len = frag_len1 - 2;  //additional byte need to put padding length

  681. 

  682.             put_payload_header(s, stream, timestamp+preroll_time, m_obj_size, m_obj_offset, payload_len, flags);

  683.             put_buffer(&asf->pb, buf, payload_len);

  684. 

  685.             if (asf->multi_payloads_present)

  686.                 asf->packet_size_left -= (payload_len + PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS);

  687.             else

  688.                 asf->packet_size_left -= (payload_len + PAYLOAD_HEADER_SIZE_SINGLE_PAYLOAD);

  689.             asf->packet_timestamp_end = timestamp;

  690. 

  691.             asf->packet_nb_payloads++;

  692.         } else {

  693.             payload_len = 0;

  694.         }

  695.         m_obj_offset += payload_len;

  696.         buf += payload_len;

  697. 

  698.         if (!asf->multi_payloads_present)

  699.             flush_packet(s);

  700.         else if (asf->packet_size_left <= (PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS + 1))

  701.             flush_packet(s);

  702.     }

  703.     stream->seq++;

  704. }

  705. 

  706. static int asf_write_packet(AVFormatContext *s, AVPacket *pkt)

  707. {

  708.     ASFContext *asf = s->priv_data;

  709.     ASFStream *stream;

  710.     int64_t duration;

  711.     AVCodecContext *codec;

  712.     int64_t packet_st,pts;

  713.     int start_sec,i;

  714. 

  715.     codec = s->streams[pkt->stream_index]->codec;

  716.     stream = &asf->streams[pkt->stream_index];

  717. 

  718.     //XXX /FIXME use duration from AVPacket (quick hack by)

  719.     pts = (pkt->pts != AV_NOPTS_VALUE) ? pkt->pts : pkt->dts;

  720.     assert(pts != AV_NOPTS_VALUE);

  721.     duration = pts * 10000;

  722.     asf->duration= FFMAX(asf->duration, duration);

  723. 

  724.     packet_st = asf->nb_packets;

  725.     put_frame(s, stream, pkt->dts, pkt->data, pkt->size, pkt->flags);

  726. 

  727.     /* check index */

  728.     if ((!asf->is_streamed) && (codec->codec_type == CODEC_TYPE_VIDEO) && (pkt->flags & PKT_FLAG_KEY)) {

  729.         start_sec = (int)(duration / INT64_C(10000000));

  730.         if (start_sec != (int)(asf->last_indexed_pts / INT64_C(10000000))) {

  731.             for(i=asf->nb_index_count;i<start_sec;i++) {

  732.                 if (i>=asf->nb_index_memory_alloc) {

  733.                     asf->nb_index_memory_alloc += ASF_INDEX_BLOCK;

  734.                     asf->index_ptr = (ASFIndex*)av_realloc( asf->index_ptr, sizeof(ASFIndex) * asf->nb_index_memory_alloc );

  735.                 }

  736.                 // store

  737.                 asf->index_ptr[i].packet_number = (uint32_t)packet_st;

  738.                 asf->index_ptr[i].packet_count  = (uint16_t)(asf->nb_packets-packet_st);

  739.                 asf->maximum_packet = FFMAX(asf->maximum_packet, (uint16_t)(asf->nb_packets-packet_st));

  740.             }

  741.             asf->nb_index_count = start_sec;

  742.             asf->last_indexed_pts = duration;

  743.         }

  744.     }

  745.     return 0;

  746. }

  747. 

  748. //

  749. static int asf_write_index(AVFormatContext *s, ASFIndex *index, uint16_t max, uint32_t count)

  750. {

  751.     ByteIOContext *pb = &s->pb;

  752.     int i;

  753. 

  754.     put_guid(pb, &simple_index_header);

  755.     put_le64(pb, 24 + 16 + 8 + 4 + 4 + (4 + 2)*count);

  756.     put_guid(pb, &my_guid);

  757.     put_le64(pb, ASF_INDEXED_INTERVAL);

  758.     put_le32(pb, max);

  759.     put_le32(pb, count);

  760.     for(i=0; i<count; i++) {

  761.         put_le32(pb, index[i].packet_number);

  762.         put_le16(pb, index[i].packet_count);

  763.     }

  764. 

  765.     return 0;

  766. }

  767. 

  768. static int asf_write_trailer(AVFormatContext *s)

  769. {

  770.     ASFContext *asf = s->priv_data;

  771.     int64_t file_size,data_size;

  772. 

  773.     /* flush the current packet */

  774.     if (asf->pb.buf_ptr > asf->pb.buffer)

  775.         flush_packet(s);

  776. 

  777.     /* write index */

  778.     data_size = url_ftell(&s->pb);

  779.     if ((!asf->is_streamed) && (asf->nb_index_count != 0)) {

  780.         asf_write_index(s, asf->index_ptr, asf->maximum_packet, asf->nb_index_count);

  781.     }

  782.     put_flush_packet(&s->pb);

  783. 

  784.     if (asf->is_streamed) {

  785.         put_chunk(s, 0x4524, 0, 0); /* end of stream */

  786.     } else {

  787.         /* rewrite an updated header */

  788.         file_size = url_ftell(&s->pb);

  789.         url_fseek(&s->pb, 0, SEEK_SET);

  790.         asf_write_header1(s, file_size, data_size - asf->data_offset);

  791.     }

  792. 

  793.     put_flush_packet(&s->pb);

  794.     av_free(asf->index_ptr);

  795.     return 0;

  796. }

  797. 

  798. #ifdef CONFIG_ASF_MUXER

  799. AVOutputFormat asf_muxer = {

  800.     "asf",

  801.     "asf format",

  802.     "video/x-ms-asf",

  803.     "asf,wmv,wma",

  804.     sizeof(ASFContext),

  805. #ifdef CONFIG_LIBMP3LAME

  806.     CODEC_ID_MP3,

  807. #else

  808.     CODEC_ID_MP2,

  809. #endif

  810.     CODEC_ID_MSMPEG4V3,

  811.     asf_write_header,

  812.     asf_write_packet,

  813.     asf_write_trailer,

  814.     .flags = AVFMT_GLOBALHEADER,

  815.     .codec_tag= (const AVCodecTag*[]){codec_asf_bmp_tags, codec_bmp_tags, codec_wav_tags, 0},

  816. };

  817. #endif

  818. 

  819. #ifdef CONFIG_ASF_STREAM_MUXER

  820. AVOutputFormat asf_stream_muxer = {

  821.     "asf_stream",

  822.     "asf format",

  823.     "video/x-ms-asf",

  824.     "asf,wmv,wma",

  825.     sizeof(ASFContext),

  826. #ifdef CONFIG_LIBMP3LAME

  827.     CODEC_ID_MP3,

  828. #else

  829.     CODEC_ID_MP2,

  830. #endif

  831.     CODEC_ID_MSMPEG4V3,

  832.     asf_write_stream_header,

  833.     asf_write_packet,

  834.     asf_write_trailer,

  835.     .flags = AVFMT_GLOBALHEADER,

  836.     .codec_tag= (const AVCodecTag*[]){codec_asf_bmp_tags, codec_bmp_tags, codec_wav_tags, 0},

  837. };

  838. #endif //CONFIG_ASF_STREAM_MUXER