mxfenc.c 53 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461
  1. /*
  2. * MXF muxer
  3. * Copyright (c) 2008 GUCAS, Zhentan Feng <spyfeng at gmail dot com>
  4. * Copyright (c) 2008 Baptiste Coudurier <baptiste dot coudurier at gmail dot com>
  5. *
  6. * This file is part of FFmpeg.
  7. *
  8. * FFmpeg is free software; you can redistribute it and/or
  9. * modify it under the terms of the GNU Lesser General Public
  10. * License as published by the Free Software Foundation; either
  11. * version 2.1 of the License, or (at your option) any later version.
  12. *
  13. * FFmpeg is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16. * Lesser General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU Lesser General Public
  19. * License along with FFmpeg; if not, write to the Free Software
  20. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21. */
  22. /*
  23. * References
  24. * SMPTE 336M KLV Data Encoding Protocol Using Key-Length-Value
  25. * SMPTE 377M MXF File Format Specifications
  26. * SMPTE 379M MXF Generic Container
  27. * SMPTE 381M Mapping MPEG Streams into the MXF Generic Container
  28. * SMPTE RP210: SMPTE Metadata Dictionary
  29. * SMPTE RP224: Registry of SMPTE Universal Labels
  30. */
  31. //#define DEBUG
  32. #include <math.h>
  33. #include <time.h>
  34. #include "libavutil/fifo.h"
  35. #include "audiointerleave.h"
  36. #include "mxf.h"
  37. static const int NTSC_samples_per_frame[] = { 1602, 1601, 1602, 1601, 1602, 0 };
  38. static const int PAL_samples_per_frame[] = { 1920, 0 };
  39. #define MXF_INDEX_CLUSTER_SIZE 4096
  40. #define KAG_SIZE 512
  41. typedef struct {
  42. int local_tag;
  43. UID uid;
  44. } MXFLocalTagPair;
  45. typedef struct {
  46. uint8_t flags;
  47. uint64_t offset;
  48. unsigned slice_offset; // offset of audio slice
  49. } MXFIndexEntry;
  50. typedef struct {
  51. AudioInterleaveContext aic;
  52. UID track_essence_element_key;
  53. int index; ///< index in mxf_essence_container_uls table
  54. const UID *codec_ul;
  55. int64_t duration;
  56. int order; ///< interleaving order if dts are equal
  57. int interlaced; ///< wether picture is interlaced
  58. int temporal_reordering;
  59. } MXFStreamContext;
  60. typedef struct {
  61. UID container_ul;
  62. UID element_ul;
  63. UID codec_ul;
  64. void (*write_desc)();
  65. } MXFContainerEssenceEntry;
  66. static const struct {
  67. enum CodecID id;
  68. int index;
  69. } mxf_essence_mappings[] = {
  70. { CODEC_ID_MPEG2VIDEO, 0 },
  71. { CODEC_ID_PCM_S24LE, 1 },
  72. { CODEC_ID_PCM_S16LE, 1 },
  73. { 0 }
  74. };
  75. static void mxf_write_wav_desc(AVFormatContext *s, AVStream *st);
  76. static void mxf_write_aes3_desc(AVFormatContext *s, AVStream *st);
  77. static void mxf_write_mpegvideo_desc(AVFormatContext *s, AVStream *st);
  78. static const MXFContainerEssenceEntry mxf_essence_container_uls[] = {
  79. { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x02,0x0D,0x01,0x03,0x01,0x02,0x04,0x60,0x01 },
  80. { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x15,0x01,0x05,0x00 },
  81. { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x00,0x00,0x00 },
  82. mxf_write_mpegvideo_desc },
  83. { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x06,0x03,0x00 },
  84. { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x16,0x01,0x03,0x00 },
  85. { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },
  86. mxf_write_aes3_desc },
  87. { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x06,0x01,0x00 },
  88. { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x16,0x01,0x01,0x00 },
  89. { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },
  90. mxf_write_wav_desc },
  91. { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },
  92. { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },
  93. { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },
  94. NULL },
  95. };
  96. typedef struct MXFContext {
  97. int64_t footer_partition_offset;
  98. int essence_container_count;
  99. uint8_t essence_containers_indices[FF_ARRAY_ELEMS(mxf_essence_container_uls)];
  100. AVRational time_base;
  101. int header_written;
  102. MXFIndexEntry *index_entries;
  103. unsigned edit_units_count;
  104. uint64_t timestamp; ///< timestamp, as year(16),month(8),day(8),hour(8),minutes(8),msec/4(8)
  105. uint8_t slice_count; /// index slice count minus 1 (1 if no audio, 0 otherwise)
  106. } MXFContext;
  107. static const uint8_t uuid_base[] = { 0xAD,0xAB,0x44,0x24,0x2f,0x25,0x4d,0xc7,0x92,0xff,0x29,0xbd };
  108. static const uint8_t umid_base[] = { 0x06,0x0A,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x01,0x0D,0x00,0x13,0x00,0x00,0x00 };
  109. /**
  110. * complete key for operation pattern, partitions, and primer pack
  111. */
  112. static const uint8_t op1a_ul[] = { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x01,0x01,0x00 };
  113. static const uint8_t footer_partition_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }; // ClosedComplete
  114. static const uint8_t primer_pack_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x05,0x01,0x00 };
  115. static const uint8_t index_table_segment_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 };
  116. static const uint8_t random_index_pack_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x11,0x01,0x00 };
  117. static const uint8_t header_open_partition_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }; // OpenIncomplete
  118. static const uint8_t header_closed_partition_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }; // ClosedComplete
  119. static const uint8_t klv_fill_key[] = { 0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x03,0x01,0x02,0x10,0x01,0x00,0x00,0x00 };
  120. /**
  121. * partial key for header metadata
  122. */
  123. static const uint8_t header_metadata_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01 };
  124. static const uint8_t multiple_desc_ul[] = { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x0D,0x01,0x03,0x01,0x02,0x7F,0x01,0x00 };
  125. /**
  126. * SMPTE RP210 http://www.smpte-ra.org/mdd/index.html
  127. */
  128. static const MXFLocalTagPair mxf_local_tag_batch[] = {
  129. // preface set
  130. { 0x3C0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x01,0x01,0x15,0x02,0x00,0x00,0x00,0x00}}, /* Instance UID */
  131. { 0x3B02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x02,0x04,0x00,0x00}}, /* Last Modified Date */
  132. { 0x3B05, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x03,0x01,0x02,0x01,0x05,0x00,0x00,0x00}}, /* Version */
  133. { 0x3B06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x06,0x04,0x00,0x00}}, /* Identifications reference */
  134. { 0x3B03, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x02,0x01,0x00,0x00}}, /* Content Storage reference */
  135. { 0x3B09, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x02,0x02,0x03,0x00,0x00,0x00,0x00}}, /* Operational Pattern UL */
  136. { 0x3B0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x02,0x02,0x10,0x02,0x01,0x00,0x00}}, /* Essence Containers UL batch */
  137. { 0x3B0B, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x02,0x02,0x10,0x02,0x02,0x00,0x00}}, /* DM Schemes UL batch */
  138. // Identification
  139. { 0x3C09, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x01,0x00,0x00,0x00}}, /* This Generation UID */
  140. { 0x3C01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x02,0x01,0x00,0x00}}, /* Company Name */
  141. { 0x3C02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x03,0x01,0x00,0x00}}, /* Product Name */
  142. { 0x3C04, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x05,0x01,0x00,0x00}}, /* Version String */
  143. { 0x3C05, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x07,0x00,0x00,0x00}}, /* Product ID */
  144. { 0x3C06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x02,0x03,0x00,0x00}}, /* Modification Date */
  145. // Content Storage
  146. { 0x1901, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x05,0x01,0x00,0x00}}, /* Package strong reference batch */
  147. { 0x1902, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x05,0x02,0x00,0x00}}, /* Package strong reference batch */
  148. // Essence Container Data
  149. { 0x2701, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x06,0x01,0x00,0x00,0x00}}, /* Linked Package UID */
  150. { 0x3F07, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x01,0x03,0x04,0x04,0x00,0x00,0x00,0x00}}, /* BodySID */
  151. // Package
  152. { 0x4401, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x01,0x01,0x15,0x10,0x00,0x00,0x00,0x00}}, /* Package UID */
  153. { 0x4405, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x01,0x03,0x00,0x00}}, /* Package Creation Date */
  154. { 0x4404, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x02,0x05,0x00,0x00}}, /* Package Modified Date */
  155. { 0x4403, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x06,0x05,0x00,0x00}}, /* Tracks Strong reference array */
  156. { 0x4701, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x02,0x03,0x00,0x00}}, /* Descriptor */
  157. // Track
  158. { 0x4801, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x01,0x07,0x01,0x01,0x00,0x00,0x00,0x00}}, /* Track ID */
  159. { 0x4804, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x01,0x04,0x01,0x03,0x00,0x00,0x00,0x00}}, /* Track Number */
  160. { 0x4B01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x30,0x04,0x05,0x00,0x00,0x00,0x00}}, /* Edit Rate */
  161. { 0x4B02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x03,0x01,0x03,0x00,0x00}}, /* Origin */
  162. { 0x4803, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x02,0x04,0x00,0x00}}, /* Sequence reference */
  163. // Sequence
  164. { 0x0201, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x07,0x01,0x00,0x00,0x00,0x00,0x00}}, /* Data Definition UL */
  165. { 0x0202, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x02,0x01,0x01,0x03,0x00,0x00}}, /* Duration */
  166. { 0x1001, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x06,0x09,0x00,0x00}}, /* Structural Components reference array */
  167. // Source Clip
  168. { 0x1201, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x07,0x02,0x01,0x03,0x01,0x04,0x00,0x00}}, /* Start position */
  169. { 0x1101, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x03,0x01,0x00,0x00,0x00}}, /* SourcePackageID */
  170. { 0x1102, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x03,0x02,0x00,0x00,0x00}}, /* SourceTrackID */
  171. // File Descriptor
  172. { 0x3F01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x06,0x01,0x01,0x04,0x06,0x0B,0x00,0x00}}, /* Sub Descriptors reference array */
  173. { 0x3006, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x06,0x01,0x01,0x03,0x05,0x00,0x00,0x00}}, /* Linked Track ID */
  174. { 0x3001, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x06,0x01,0x01,0x00,0x00,0x00,0x00}}, /* SampleRate */
  175. { 0x3004, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x01,0x02,0x00,0x00}}, /* Essence Container */
  176. // Generic Picture Essence Descriptor
  177. { 0x320C, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x03,0x01,0x04,0x00,0x00,0x00}}, /* Frame Layout */
  178. { 0x320D, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x03,0x02,0x05,0x00,0x00,0x00}}, /* Video Line Map */
  179. { 0x3203, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x02,0x02,0x00,0x00,0x00}}, /* Stored Width */
  180. { 0x3202, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x02,0x01,0x00,0x00,0x00}}, /* Stored Height */
  181. { 0x3209, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x0C,0x00,0x00,0x00}}, /* Display Width */
  182. { 0x3208, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x0B,0x00,0x00,0x00}}, /* Display Height */
  183. { 0x320E, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x01,0x01,0x01,0x00,0x00,0x00}}, /* Aspect Ratio */
  184. { 0x3201, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x06,0x01,0x00,0x00,0x00,0x00}}, /* Picture Essence Coding */
  185. // Generic Sound Essence Descriptor
  186. { 0x3D02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x03,0x01,0x04,0x00,0x00,0x00}}, /* Locked/Unlocked */
  187. { 0x3D03, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x03,0x01,0x01,0x01,0x00,0x00}}, /* Audio sampling rate */
  188. { 0x3D07, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x01,0x01,0x04,0x00,0x00,0x00}}, /* ChannelCount */
  189. { 0x3D01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x04,0x02,0x03,0x03,0x04,0x00,0x00,0x00}}, /* Quantization bits */
  190. { 0x3D06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x02,0x04,0x02,0x00,0x00,0x00,0x00}}, /* Sound Essence Compression */
  191. // Index Table Segment
  192. { 0x3F0B, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x05,0x30,0x04,0x06,0x00,0x00,0x00,0x00}}, /* Index Edit Rate */
  193. { 0x3F0C, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x07,0x02,0x01,0x03,0x01,0x0A,0x00,0x00}}, /* Index Start Position */
  194. { 0x3F0D, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x07,0x02,0x02,0x01,0x01,0x02,0x00,0x00}}, /* Index Duration */
  195. { 0x3F05, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x06,0x02,0x01,0x00,0x00,0x00,0x00,0x00}}, /* Edit Unit Byte Count */
  196. { 0x3F06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x01,0x03,0x04,0x05,0x00,0x00,0x00,0x00}}, /* IndexSID */
  197. { 0x3F08, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x04,0x04,0x04,0x01,0x01,0x00,0x00,0x00}}, /* Slice Count */
  198. { 0x3F09, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x04,0x04,0x01,0x06,0x00,0x00,0x00}}, /* Delta Entry Array */
  199. { 0x3F0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x04,0x04,0x02,0x05,0x00,0x00,0x00}}, /* Index Entry Array */
  200. // MPEG video Descriptor
  201. { 0x8000, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x01,0x06,0x02,0x01,0x0B,0x00,0x00}}, /* BitRate */
  202. // Wave Audio Essence Descriptor
  203. { 0x3D09, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x03,0x03,0x05,0x00,0x00,0x00}}, /* Average Bytes Per Second */
  204. { 0x3D0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x03,0x02,0x01,0x00,0x00,0x00}}, /* Block Align */
  205. };
  206. static void mxf_write_uuid(ByteIOContext *pb, enum MXFMetadataSetType type, int value)
  207. {
  208. put_buffer(pb, uuid_base, 12);
  209. put_be16(pb, type);
  210. put_be16(pb, value);
  211. }
  212. static void mxf_write_umid(ByteIOContext *pb, enum MXFMetadataSetType type, int value)
  213. {
  214. put_buffer(pb, umid_base, 16);
  215. mxf_write_uuid(pb, type, value);
  216. }
  217. static void mxf_write_refs_count(ByteIOContext *pb, int ref_count)
  218. {
  219. put_be32(pb, ref_count);
  220. put_be32(pb, 16);
  221. }
  222. static int klv_ber_length(uint64_t len)
  223. {
  224. if (len < 128)
  225. return 1;
  226. else
  227. return (av_log2(len) >> 3) + 2;
  228. }
  229. static int klv_encode_ber_length(ByteIOContext *pb, uint64_t len)
  230. {
  231. // Determine the best BER size
  232. int size;
  233. if (len < 128) {
  234. //short form
  235. put_byte(pb, len);
  236. return 1;
  237. }
  238. size = (av_log2(len) >> 3) + 1;
  239. // long form
  240. put_byte(pb, 0x80 + size);
  241. while(size) {
  242. size--;
  243. put_byte(pb, len >> 8 * size & 0xff);
  244. }
  245. return 0;
  246. }
  247. /*
  248. * Get essence container ul index
  249. */
  250. static int mxf_get_essence_container_ul_index(enum CodecID id)
  251. {
  252. int i;
  253. for (i = 0; mxf_essence_mappings[i].id; i++)
  254. if (mxf_essence_mappings[i].id == id)
  255. return mxf_essence_mappings[i].index;
  256. return -1;
  257. }
  258. static void mxf_write_primer_pack(AVFormatContext *s)
  259. {
  260. ByteIOContext *pb = s->pb;
  261. int local_tag_number, i = 0;
  262. local_tag_number = FF_ARRAY_ELEMS(mxf_local_tag_batch);
  263. put_buffer(pb, primer_pack_key, 16);
  264. klv_encode_ber_length(pb, local_tag_number * 18 + 8);
  265. put_be32(pb, local_tag_number); // local_tag num
  266. put_be32(pb, 18); // item size, always 18 according to the specs
  267. for (i = 0; i < local_tag_number; i++) {
  268. put_be16(pb, mxf_local_tag_batch[i].local_tag);
  269. put_buffer(pb, mxf_local_tag_batch[i].uid, 16);
  270. }
  271. }
  272. static void mxf_write_local_tag(ByteIOContext *pb, int size, int tag)
  273. {
  274. put_be16(pb, tag);
  275. put_be16(pb, size);
  276. }
  277. static void mxf_write_metadata_key(ByteIOContext *pb, unsigned int value)
  278. {
  279. put_buffer(pb, header_metadata_key, 13);
  280. put_be24(pb, value);
  281. }
  282. static void mxf_free(AVFormatContext *s)
  283. {
  284. int i;
  285. for (i = 0; i < s->nb_streams; i++) {
  286. AVStream *st = s->streams[i];
  287. av_freep(&st->priv_data);
  288. }
  289. }
  290. static const MXFDataDefinitionUL *mxf_get_data_definition_ul(enum CodecType type)
  291. {
  292. const MXFDataDefinitionUL *uls = ff_mxf_data_definition_uls;
  293. while (uls->type != CODEC_TYPE_DATA) {
  294. if (type == uls->type)
  295. break;
  296. uls++;
  297. }
  298. return uls;
  299. }
  300. static void mxf_write_essence_container_refs(AVFormatContext *s)
  301. {
  302. MXFContext *c = s->priv_data;
  303. ByteIOContext *pb = s->pb;
  304. int i;
  305. mxf_write_refs_count(pb, c->essence_container_count);
  306. av_log(s,AV_LOG_DEBUG, "essence container count:%d\n", c->essence_container_count);
  307. for (i = 0; i < c->essence_container_count; i++) {
  308. put_buffer(pb, mxf_essence_container_uls[c->essence_containers_indices[i]].container_ul, 16);
  309. PRINT_KEY(s, "essence container ul:\n", mxf_essence_container_uls[c->essence_containers_indices[i]].container_ul);
  310. }
  311. }
  312. static void mxf_write_preface(AVFormatContext *s)
  313. {
  314. MXFContext *mxf = s->priv_data;
  315. ByteIOContext *pb = s->pb;
  316. mxf_write_metadata_key(pb, 0x012f00);
  317. PRINT_KEY(s, "preface key", pb->buf_ptr - 16);
  318. klv_encode_ber_length(pb, 130 + 16 * mxf->essence_container_count);
  319. // write preface set uid
  320. mxf_write_local_tag(pb, 16, 0x3C0A);
  321. mxf_write_uuid(pb, Preface, 0);
  322. PRINT_KEY(s, "preface uid", pb->buf_ptr - 16);
  323. // last modified date
  324. mxf_write_local_tag(pb, 8, 0x3B02);
  325. put_be64(pb, mxf->timestamp);
  326. // write version
  327. mxf_write_local_tag(pb, 2, 0x3B05);
  328. put_be16(pb, 1);
  329. // write identification_refs
  330. mxf_write_local_tag(pb, 16 + 8, 0x3B06);
  331. mxf_write_refs_count(pb, 1);
  332. mxf_write_uuid(pb, Identification, 0);
  333. // write content_storage_refs
  334. mxf_write_local_tag(pb, 16, 0x3B03);
  335. mxf_write_uuid(pb, ContentStorage, 0);
  336. mxf_write_local_tag(pb, 16, 0x3B09);
  337. put_buffer(pb, op1a_ul, 16);
  338. // write essence_container_refs
  339. mxf_write_local_tag(pb, 8 + 16 * mxf->essence_container_count, 0x3B0A);
  340. mxf_write_essence_container_refs(s);
  341. // write dm_scheme_refs
  342. mxf_write_local_tag(pb, 8, 0x3B0B);
  343. put_be64(pb, 0);
  344. }
  345. /*
  346. * Write a local tag containing an ascii string as utf-16
  347. */
  348. static void mxf_write_local_tag_utf16(ByteIOContext *pb, int tag, const char *value)
  349. {
  350. int i, size = strlen(value);
  351. mxf_write_local_tag(pb, size*2, tag);
  352. for (i = 0; i < size; i++)
  353. put_be16(pb, value[i]);
  354. }
  355. static void mxf_write_identification(AVFormatContext *s)
  356. {
  357. MXFContext *mxf = s->priv_data;
  358. ByteIOContext *pb = s->pb;
  359. const char *company = "FFmpeg";
  360. const char *product = "OP1a Muxer";
  361. const char *version;
  362. int length;
  363. mxf_write_metadata_key(pb, 0x013000);
  364. PRINT_KEY(s, "identification key", pb->buf_ptr - 16);
  365. version = s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT ?
  366. "0.0.0" : AV_STRINGIFY(LIBAVFORMAT_VERSION);
  367. length = 84 + (strlen(company)+strlen(product)+strlen(version))*2; // utf-16
  368. klv_encode_ber_length(pb, length);
  369. // write uid
  370. mxf_write_local_tag(pb, 16, 0x3C0A);
  371. mxf_write_uuid(pb, Identification, 0);
  372. PRINT_KEY(s, "identification uid", pb->buf_ptr - 16);
  373. // write generation uid
  374. mxf_write_local_tag(pb, 16, 0x3C09);
  375. mxf_write_uuid(pb, Identification, 1);
  376. mxf_write_local_tag_utf16(pb, 0x3C01, company); // Company Name
  377. mxf_write_local_tag_utf16(pb, 0x3C02, product); // Product Name
  378. mxf_write_local_tag_utf16(pb, 0x3C04, version); // Version String
  379. // write product uid
  380. mxf_write_local_tag(pb, 16, 0x3C05);
  381. mxf_write_uuid(pb, Identification, 2);
  382. // modification date
  383. mxf_write_local_tag(pb, 8, 0x3C06);
  384. put_be64(pb, mxf->timestamp);
  385. }
  386. static void mxf_write_content_storage(AVFormatContext *s)
  387. {
  388. ByteIOContext *pb = s->pb;
  389. mxf_write_metadata_key(pb, 0x011800);
  390. PRINT_KEY(s, "content storage key", pb->buf_ptr - 16);
  391. klv_encode_ber_length(pb, 92);
  392. // write uid
  393. mxf_write_local_tag(pb, 16, 0x3C0A);
  394. mxf_write_uuid(pb, ContentStorage, 0);
  395. PRINT_KEY(s, "content storage uid", pb->buf_ptr - 16);
  396. // write package reference
  397. mxf_write_local_tag(pb, 16 * 2 + 8, 0x1901);
  398. mxf_write_refs_count(pb, 2);
  399. mxf_write_uuid(pb, MaterialPackage, 0);
  400. mxf_write_uuid(pb, SourcePackage, 0);
  401. // write essence container data
  402. mxf_write_local_tag(pb, 8 + 16, 0x1902);
  403. mxf_write_refs_count(pb, 1);
  404. mxf_write_uuid(pb, EssenceContainerData, 0);
  405. }
  406. static void mxf_write_track(AVFormatContext *s, AVStream *st, enum MXFMetadataSetType type)
  407. {
  408. MXFContext *mxf = s->priv_data;
  409. ByteIOContext *pb = s->pb;
  410. MXFStreamContext *sc = st->priv_data;
  411. mxf_write_metadata_key(pb, 0x013b00);
  412. PRINT_KEY(s, "track key", pb->buf_ptr - 16);
  413. klv_encode_ber_length(pb, 80);
  414. // write track uid
  415. mxf_write_local_tag(pb, 16, 0x3C0A);
  416. mxf_write_uuid(pb, type == MaterialPackage ? Track : Track + TypeBottom, st->index);
  417. PRINT_KEY(s, "track uid", pb->buf_ptr - 16);
  418. // write track id
  419. mxf_write_local_tag(pb, 4, 0x4801);
  420. put_be32(pb, st->index);
  421. // write track number
  422. mxf_write_local_tag(pb, 4, 0x4804);
  423. if (type == MaterialPackage)
  424. put_be32(pb, 0); // track number of material package is 0
  425. else
  426. put_buffer(pb, sc->track_essence_element_key + 12, 4);
  427. mxf_write_local_tag(pb, 8, 0x4B01);
  428. put_be32(pb, mxf->time_base.den);
  429. put_be32(pb, mxf->time_base.num);
  430. // write origin
  431. mxf_write_local_tag(pb, 8, 0x4B02);
  432. put_be64(pb, 0);
  433. // write sequence refs
  434. mxf_write_local_tag(pb, 16, 0x4803);
  435. mxf_write_uuid(pb, type == MaterialPackage ? Sequence: Sequence + TypeBottom, st->index);
  436. }
  437. static void mxf_write_common_fields(ByteIOContext *pb, AVStream *st)
  438. {
  439. const MXFDataDefinitionUL *data_def_ul = mxf_get_data_definition_ul(st->codec->codec_type);
  440. MXFStreamContext *sc = st->priv_data;
  441. // find data define uls
  442. mxf_write_local_tag(pb, 16, 0x0201);
  443. put_buffer(pb, data_def_ul->uid, 16);
  444. // write duration
  445. mxf_write_local_tag(pb, 8, 0x0202);
  446. put_be64(pb, sc->duration);
  447. }
  448. static void mxf_write_sequence(AVFormatContext *s, AVStream *st, enum MXFMetadataSetType type)
  449. {
  450. ByteIOContext *pb = s->pb;
  451. mxf_write_metadata_key(pb, 0x010f00);
  452. PRINT_KEY(s, "sequence key", pb->buf_ptr - 16);
  453. klv_encode_ber_length(pb, 80);
  454. mxf_write_local_tag(pb, 16, 0x3C0A);
  455. mxf_write_uuid(pb, type == MaterialPackage ? Sequence: Sequence + TypeBottom, st->index);
  456. PRINT_KEY(s, "sequence uid", pb->buf_ptr - 16);
  457. mxf_write_common_fields(pb, st);
  458. // write structural component
  459. mxf_write_local_tag(pb, 16 + 8, 0x1001);
  460. mxf_write_refs_count(pb, 1);
  461. mxf_write_uuid(pb, type == MaterialPackage ? SourceClip: SourceClip + TypeBottom, st->index);
  462. }
  463. static void mxf_write_structural_component(AVFormatContext *s, AVStream *st, enum MXFMetadataSetType type)
  464. {
  465. ByteIOContext *pb = s->pb;
  466. int i;
  467. mxf_write_metadata_key(pb, 0x011100);
  468. PRINT_KEY(s, "sturctural component key", pb->buf_ptr - 16);
  469. klv_encode_ber_length(pb, 108);
  470. // write uid
  471. mxf_write_local_tag(pb, 16, 0x3C0A);
  472. mxf_write_uuid(pb, type == MaterialPackage ? SourceClip: SourceClip + TypeBottom, st->index);
  473. PRINT_KEY(s, "structural component uid", pb->buf_ptr - 16);
  474. mxf_write_common_fields(pb, st);
  475. // write start_position
  476. mxf_write_local_tag(pb, 8, 0x1201);
  477. put_be64(pb, 0);
  478. // write source package uid, end of the reference
  479. mxf_write_local_tag(pb, 32, 0x1101);
  480. if (type == SourcePackage) {
  481. for (i = 0; i < 4; i++)
  482. put_be64(pb, 0);
  483. } else
  484. mxf_write_umid(pb, SourcePackage, 0);
  485. // write source track id
  486. mxf_write_local_tag(pb, 4, 0x1102);
  487. if (type == SourcePackage)
  488. put_be32(pb, 0);
  489. else
  490. put_be32(pb, st->index);
  491. }
  492. static void mxf_write_multi_descriptor(AVFormatContext *s)
  493. {
  494. MXFContext *mxf = s->priv_data;
  495. ByteIOContext *pb = s->pb;
  496. int i;
  497. mxf_write_metadata_key(pb, 0x014400);
  498. PRINT_KEY(s, "multiple descriptor key", pb->buf_ptr - 16);
  499. klv_encode_ber_length(pb, 64 + 16 * s->nb_streams);
  500. mxf_write_local_tag(pb, 16, 0x3C0A);
  501. mxf_write_uuid(pb, MultipleDescriptor, 0);
  502. PRINT_KEY(s, "multi_desc uid", pb->buf_ptr - 16);
  503. // write sample rate
  504. mxf_write_local_tag(pb, 8, 0x3001);
  505. put_be32(pb, mxf->time_base.den);
  506. put_be32(pb, mxf->time_base.num);
  507. // write essence container ul
  508. mxf_write_local_tag(pb, 16, 0x3004);
  509. put_buffer(pb, multiple_desc_ul, 16);
  510. // write sub descriptor refs
  511. mxf_write_local_tag(pb, s->nb_streams * 16 + 8, 0x3F01);
  512. mxf_write_refs_count(pb, s->nb_streams);
  513. for (i = 0; i < s->nb_streams; i++)
  514. mxf_write_uuid(pb, SubDescriptor, i);
  515. }
  516. static void mxf_write_generic_desc(AVFormatContext *s, AVStream *st, const UID key, unsigned size)
  517. {
  518. MXFContext *mxf = s->priv_data;
  519. MXFStreamContext *sc = st->priv_data;
  520. ByteIOContext *pb = s->pb;
  521. put_buffer(pb, key, 16);
  522. klv_encode_ber_length(pb, size);
  523. mxf_write_local_tag(pb, 16, 0x3C0A);
  524. mxf_write_uuid(pb, SubDescriptor, st->index);
  525. mxf_write_local_tag(pb, 4, 0x3006);
  526. put_be32(pb, st->index);
  527. mxf_write_local_tag(pb, 8, 0x3001);
  528. put_be32(pb, mxf->time_base.den);
  529. put_be32(pb, mxf->time_base.num);
  530. mxf_write_local_tag(pb, 16, 0x3004);
  531. put_buffer(pb, mxf_essence_container_uls[sc->index].container_ul, 16);
  532. }
  533. static const UID mxf_mpegvideo_descriptor_key = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 };
  534. static const UID mxf_wav_descriptor_key = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 };
  535. static const UID mxf_aes3_descriptor_key = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 };
  536. static void mxf_write_mpegvideo_desc(AVFormatContext *s, AVStream *st)
  537. {
  538. MXFStreamContext *sc = st->priv_data;
  539. ByteIOContext *pb = s->pb;
  540. int stored_height = (st->codec->height+15)/16*16;
  541. AVRational dar;
  542. int f1, f2;
  543. mxf_write_generic_desc(s, st, mxf_mpegvideo_descriptor_key, 153+sc->interlaced*4);
  544. mxf_write_local_tag(pb, 4, 0x3203);
  545. put_be32(pb, st->codec->width);
  546. mxf_write_local_tag(pb, 4, 0x3202);
  547. put_be32(pb, stored_height>>sc->interlaced);
  548. mxf_write_local_tag(pb, 4, 0x3209);
  549. put_be32(pb, st->codec->width);
  550. mxf_write_local_tag(pb, 4, 0x3208);
  551. put_be32(pb, st->codec->height>>sc->interlaced);
  552. // bit rate
  553. mxf_write_local_tag(pb, 4, 0x8000);
  554. put_be32(pb, st->codec->bit_rate);
  555. // frame layout
  556. mxf_write_local_tag(pb, 1, 0x320C);
  557. put_byte(pb, sc->interlaced);
  558. // video line map
  559. switch (st->codec->height) {
  560. case 576: f1 = 23; f2 = 336; break;
  561. case 608: f1 = 7; f2 = 320; break;
  562. case 480: f1 = 20; f2 = 283; break;
  563. case 512: f1 = 7; f2 = 270; break;
  564. case 720: f1 = 26; f2 = 0; break; // progressive
  565. case 1080: f1 = 21; f2 = 584; break;
  566. default: f1 = 0; f2 = 0; break;
  567. }
  568. if (!sc->interlaced) {
  569. f2 = 0;
  570. f1 *= 2;
  571. }
  572. mxf_write_local_tag(pb, 12+sc->interlaced*4, 0x320D);
  573. put_be32(pb, sc->interlaced ? 2 : 1);
  574. put_be32(pb, 4);
  575. put_be32(pb, f1);
  576. if (sc->interlaced)
  577. put_be32(pb, f2);
  578. av_reduce(&dar.num, &dar.den,
  579. st->codec->width*st->codec->sample_aspect_ratio.num,
  580. st->codec->height*st->codec->sample_aspect_ratio.den,
  581. 1024*1024);
  582. mxf_write_local_tag(pb, 8, 0x320E);
  583. put_be32(pb, dar.num);
  584. put_be32(pb, dar.den);
  585. mxf_write_local_tag(pb, 16, 0x3201);
  586. put_buffer(pb, *sc->codec_ul, 16);
  587. }
  588. static void mxf_write_generic_sound_desc(AVFormatContext *s, AVStream *st, const UID key, unsigned size)
  589. {
  590. ByteIOContext *pb = s->pb;
  591. mxf_write_generic_desc(s, st, key, size);
  592. // audio locked
  593. mxf_write_local_tag(pb, 1, 0x3D02);
  594. put_byte(pb, 1);
  595. // write audio sampling rate
  596. mxf_write_local_tag(pb, 8, 0x3D03);
  597. put_be32(pb, st->codec->sample_rate);
  598. put_be32(pb, 1);
  599. mxf_write_local_tag(pb, 4, 0x3D07);
  600. put_be32(pb, st->codec->channels);
  601. mxf_write_local_tag(pb, 4, 0x3D01);
  602. put_be32(pb, av_get_bits_per_sample(st->codec->codec_id));
  603. }
  604. static void mxf_write_wav_common_desc(AVFormatContext *s, AVStream *st, const UID key, unsigned size)
  605. {
  606. ByteIOContext *pb = s->pb;
  607. mxf_write_generic_sound_desc(s, st, key, size);
  608. mxf_write_local_tag(pb, 2, 0x3D0A);
  609. put_be16(pb, st->codec->block_align);
  610. // avg bytes per sec
  611. mxf_write_local_tag(pb, 4, 0x3D09);
  612. put_be32(pb, st->codec->block_align*st->codec->sample_rate);
  613. }
  614. static void mxf_write_wav_desc(AVFormatContext *s, AVStream *st)
  615. {
  616. mxf_write_wav_common_desc(s, st, mxf_wav_descriptor_key, 107);
  617. }
  618. static void mxf_write_aes3_desc(AVFormatContext *s, AVStream *st)
  619. {
  620. mxf_write_wav_common_desc(s, st, mxf_aes3_descriptor_key, 107);
  621. }
  622. static void mxf_write_package(AVFormatContext *s, enum MXFMetadataSetType type)
  623. {
  624. MXFContext *mxf = s->priv_data;
  625. ByteIOContext *pb = s->pb;
  626. int i;
  627. if (type == MaterialPackage) {
  628. mxf_write_metadata_key(pb, 0x013600);
  629. PRINT_KEY(s, "Material Package key", pb->buf_ptr - 16);
  630. klv_encode_ber_length(pb, 92 + 16 * s->nb_streams);
  631. } else {
  632. mxf_write_metadata_key(pb, 0x013700);
  633. PRINT_KEY(s, "Source Package key", pb->buf_ptr - 16);
  634. klv_encode_ber_length(pb, 112 + 16 * s->nb_streams); // 20 bytes length for descriptor reference
  635. }
  636. // write uid
  637. mxf_write_local_tag(pb, 16, 0x3C0A);
  638. mxf_write_uuid(pb, type, 0);
  639. av_log(s,AV_LOG_DEBUG, "package type:%d\n", type);
  640. PRINT_KEY(s, "package uid", pb->buf_ptr - 16);
  641. // write package umid
  642. mxf_write_local_tag(pb, 32, 0x4401);
  643. mxf_write_umid(pb, type, 0);
  644. PRINT_KEY(s, "package umid second part", pb->buf_ptr - 16);
  645. // package creation date
  646. mxf_write_local_tag(pb, 8, 0x4405);
  647. put_be64(pb, mxf->timestamp);
  648. // package modified date
  649. mxf_write_local_tag(pb, 8, 0x4404);
  650. put_be64(pb, mxf->timestamp);
  651. // write track refs
  652. mxf_write_local_tag(pb, s->nb_streams * 16 + 8, 0x4403);
  653. mxf_write_refs_count(pb, s->nb_streams);
  654. for (i = 0; i < s->nb_streams; i++)
  655. mxf_write_uuid(pb, type == MaterialPackage ? Track : Track + TypeBottom, i);
  656. // write multiple descriptor reference
  657. if (type == SourcePackage) {
  658. mxf_write_local_tag(pb, 16, 0x4701);
  659. if (s->nb_streams > 1) {
  660. mxf_write_uuid(pb, MultipleDescriptor, 0);
  661. mxf_write_multi_descriptor(s);
  662. } else
  663. mxf_write_uuid(pb, SubDescriptor, 0);
  664. }
  665. for (i = 0; i < s->nb_streams; i++) {
  666. AVStream *st = s->streams[i];
  667. mxf_write_track(s, st, type);
  668. mxf_write_sequence(s, st, type);
  669. mxf_write_structural_component(s, st, type);
  670. if (type == SourcePackage) {
  671. MXFStreamContext *sc = st->priv_data;
  672. mxf_essence_container_uls[sc->index].write_desc(s, st);
  673. }
  674. }
  675. }
  676. static int mxf_write_essence_container_data(AVFormatContext *s)
  677. {
  678. ByteIOContext *pb = s->pb;
  679. mxf_write_metadata_key(pb, 0x012300);
  680. klv_encode_ber_length(pb, 72);
  681. mxf_write_local_tag(pb, 16, 0x3C0A); // Instance UID
  682. mxf_write_uuid(pb, EssenceContainerData, 0);
  683. mxf_write_local_tag(pb, 32, 0x2701); // Linked Package UID
  684. mxf_write_umid(pb, SourcePackage, 0);
  685. mxf_write_local_tag(pb, 4, 0x3F07); // BodySID
  686. put_be32(pb, 1);
  687. mxf_write_local_tag(pb, 4, 0x3F06); // IndexSID
  688. put_be32(pb, 2);
  689. return 0;
  690. }
  691. static int mxf_write_header_metadata_sets(AVFormatContext *s)
  692. {
  693. mxf_write_preface(s);
  694. mxf_write_identification(s);
  695. mxf_write_content_storage(s);
  696. mxf_write_package(s, MaterialPackage);
  697. mxf_write_package(s, SourcePackage);
  698. mxf_write_essence_container_data(s);
  699. return 0;
  700. }
  701. static unsigned klv_fill_size(uint64_t size)
  702. {
  703. unsigned pad = KAG_SIZE - (size & (KAG_SIZE-1));
  704. if (pad < 17) // smallest fill item possible
  705. return pad + KAG_SIZE;
  706. else
  707. return pad & (KAG_SIZE-1);
  708. }
  709. static int mxf_write_index_table_segment(AVFormatContext *s)
  710. {
  711. MXFContext *mxf = s->priv_data;
  712. ByteIOContext *pb = s->pb;
  713. int i, j, ret;
  714. int temporal_reordering = 0;
  715. int last_key_index = 0, key_index = 0;
  716. av_log(s, AV_LOG_DEBUG, "edit units count %d\n", mxf->edit_units_count);
  717. put_buffer(pb, index_table_segment_key, 16);
  718. ret = klv_encode_ber_length(pb, 109 + (s->nb_streams+1)*6 +
  719. mxf->edit_units_count*(11+mxf->slice_count*4));
  720. // instance id
  721. mxf_write_local_tag(pb, 16, 0x3C0A);
  722. mxf_write_uuid(pb, IndexTableSegment, 0);
  723. // index edit rate
  724. mxf_write_local_tag(pb, 8, 0x3F0B);
  725. put_be32(pb, mxf->time_base.num);
  726. put_be32(pb, mxf->time_base.den);
  727. // index start position
  728. mxf_write_local_tag(pb, 8, 0x3F0C);
  729. put_be64(pb, 0);
  730. // index duration
  731. mxf_write_local_tag(pb, 8, 0x3F0D);
  732. put_be64(pb, mxf->edit_units_count);
  733. // edit unit byte count
  734. mxf_write_local_tag(pb, 4, 0x3F05);
  735. put_be32(pb, 0);
  736. // index sid
  737. mxf_write_local_tag(pb, 4, 0x3F06);
  738. put_be32(pb, 2);
  739. // body sid
  740. mxf_write_local_tag(pb, 4, 0x3F07);
  741. put_be32(pb, 1);
  742. // real slice count - 1
  743. mxf_write_local_tag(pb, 1, 0x3F08);
  744. put_byte(pb, mxf->slice_count);
  745. // delta entry array
  746. mxf_write_local_tag(pb, 8 + (s->nb_streams+1)*6, 0x3F09);
  747. put_be32(pb, s->nb_streams+1); // num of entries
  748. put_be32(pb, 6); // size of one entry
  749. // write system item delta entry
  750. put_byte(pb, 0);
  751. put_byte(pb, 0); // slice entry
  752. put_be32(pb, 0); // element delta
  753. for (i = 0; i < s->nb_streams; i++) {
  754. AVStream *st = s->streams[i];
  755. MXFStreamContext *sc = st->priv_data;
  756. put_byte(pb, sc->temporal_reordering);
  757. if (sc->temporal_reordering)
  758. temporal_reordering = 1;
  759. // slice number
  760. if (i == 0) { // video track
  761. put_byte(pb, 0); // slice number
  762. put_be32(pb, KAG_SIZE); // system item size including klv fill
  763. } else { // audio track
  764. unsigned audio_frame_size = sc->aic.samples[0]*sc->aic.sample_size;
  765. audio_frame_size += klv_fill_size(audio_frame_size);
  766. put_byte(pb, 1);
  767. put_be32(pb, (i-1)*audio_frame_size); // element delta
  768. }
  769. }
  770. mxf_write_local_tag(pb, 8 + mxf->edit_units_count*(11+mxf->slice_count*4), 0x3F0A);
  771. put_be32(pb, mxf->edit_units_count); // num of entries
  772. put_be32(pb, 11+mxf->slice_count*4); // size of one entry
  773. for (i = 0; i < mxf->edit_units_count; i++) {
  774. if (temporal_reordering) {
  775. int temporal_offset = 0;
  776. for (j = i+1; j < mxf->edit_units_count; j++) {
  777. temporal_offset++;
  778. if (mxf->index_entries[j].flags & 0x10) { // backward prediction
  779. // next is not b, so is reordered
  780. if (!(mxf->index_entries[i+1].flags & 0x10)) {
  781. if ((mxf->index_entries[i].flags & 0x11) == 0) // i frame
  782. temporal_offset = 0;
  783. else
  784. temporal_offset = -temporal_offset;
  785. }
  786. break;
  787. }
  788. }
  789. put_byte(pb, temporal_offset);
  790. } else
  791. put_byte(pb, 0);
  792. if (!(mxf->index_entries[i].flags & 0x33)) { // I frame
  793. last_key_index = key_index;
  794. key_index = i;
  795. }
  796. if (mxf->index_entries[i].flags & 0x10 && // backward prediction
  797. !(mxf->index_entries[key_index].flags & 0x80)) { // open gop
  798. put_byte(pb, last_key_index - i);
  799. } else {
  800. put_byte(pb, key_index - i); // key frame offset
  801. if ((mxf->index_entries[i].flags & 0x20) == 0x20) // only forward
  802. last_key_index = key_index;
  803. }
  804. put_byte(pb, mxf->index_entries[i].flags);
  805. // stream offset
  806. put_be64(pb, mxf->index_entries[i].offset - mxf->index_entries[0].offset);
  807. if (s->nb_streams > 1)
  808. put_be32(pb, mxf->index_entries[i].slice_offset);
  809. }
  810. return ret;
  811. }
  812. static void mxf_write_partition(AVFormatContext *s, int bodysid,
  813. int indexsid, unsigned index_byte_count,
  814. const uint8_t *key, int write_metadata)
  815. {
  816. MXFContext *mxf = s->priv_data;
  817. ByteIOContext *pb = s->pb;
  818. int64_t header_byte_count_offset;
  819. // write klv
  820. put_buffer(pb, key, 16);
  821. klv_encode_ber_length(pb, 88 + 16 * mxf->essence_container_count);
  822. // write partition value
  823. put_be16(pb, 1); // majorVersion
  824. put_be16(pb, 2); // minorVersion
  825. put_be32(pb, KAG_SIZE); // KAGSize
  826. put_be64(pb, url_ftell(pb) - 25); // thisPartition
  827. put_be64(pb, 0); // previousPartition
  828. put_be64(pb, mxf->footer_partition_offset); // footerPartition
  829. // set offset
  830. header_byte_count_offset = url_ftell(pb);
  831. put_be64(pb, 0); // headerByteCount, update later
  832. // indexTable
  833. put_be64(pb, index_byte_count); // indexByteCount
  834. put_be32(pb, indexsid); // indexSID
  835. put_be64(pb, 0); // bodyOffset
  836. put_be32(pb, bodysid); // bodySID
  837. put_buffer(pb, op1a_ul, 16); // operational pattern
  838. // essence container
  839. mxf_write_essence_container_refs(s);
  840. if (write_metadata) {
  841. // mark the start of the headermetadata and calculate metadata size
  842. int64_t pos, start = url_ftell(s->pb);
  843. unsigned header_byte_count;
  844. mxf_write_primer_pack(s);
  845. mxf_write_header_metadata_sets(s);
  846. pos = url_ftell(s->pb);
  847. header_byte_count = pos - start + klv_fill_size(pos);
  848. // update header_byte_count
  849. url_fseek(pb, header_byte_count_offset, SEEK_SET);
  850. put_be64(pb, header_byte_count);
  851. url_fseek(pb, pos, SEEK_SET);
  852. }
  853. put_flush_packet(pb);
  854. }
  855. static const UID mxf_mpeg2_codec_uls[] = {
  856. { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x01,0x10,0x00 }, // MP-ML I-Frame
  857. { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x01,0x11,0x00 }, // MP-ML Long GOP
  858. { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x02,0x02,0x00 }, // 422P-ML I-Frame
  859. { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x02,0x03,0x00 }, // 422P-ML Long GOP
  860. { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x03,0x02,0x00 }, // MP-HL I-Frame
  861. { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x03,0x03,0x00 }, // MP-HL Long GOP
  862. { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x04,0x02,0x00 }, // 422P-HL I-Frame
  863. { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x04,0x03,0x00 }, // 422P-HL Long GOP
  864. };
  865. static const UID *mxf_get_mpeg2_codec_ul(AVCodecContext *avctx)
  866. {
  867. if (avctx->profile == 4) { // Main
  868. if (avctx->level == 8) // Main
  869. return avctx->gop_size ?
  870. &mxf_mpeg2_codec_uls[1] :
  871. &mxf_mpeg2_codec_uls[0];
  872. else if (avctx->level == 4) // High
  873. return avctx->gop_size ?
  874. &mxf_mpeg2_codec_uls[5] :
  875. &mxf_mpeg2_codec_uls[4];
  876. } else if (avctx->profile == 0) { // 422
  877. if (avctx->level == 5) // Main
  878. return avctx->gop_size ?
  879. &mxf_mpeg2_codec_uls[3] :
  880. &mxf_mpeg2_codec_uls[2];
  881. else if (avctx->level == 2) // High
  882. return avctx->gop_size ?
  883. &mxf_mpeg2_codec_uls[7] :
  884. &mxf_mpeg2_codec_uls[6];
  885. }
  886. return NULL;
  887. }
  888. static int mxf_parse_mpeg2_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt)
  889. {
  890. MXFContext *mxf = s->priv_data;
  891. MXFStreamContext *sc = st->priv_data;
  892. uint32_t c = -1;
  893. int i;
  894. mxf->index_entries[mxf->edit_units_count].flags = 0;
  895. for(i = 0; i < pkt->size - 4; i++) {
  896. c = (c<<8) + pkt->data[i];
  897. if (c == 0x1B5) {
  898. if (i + 2 < pkt->size && (pkt->data[i+1] & 0xf0) == 0x10) { // seq ext
  899. st->codec->profile = pkt->data[i+1] & 0x07;
  900. st->codec->level = pkt->data[i+2] >> 4;
  901. } else if (i + 5 < pkt->size && (pkt->data[i+1] & 0xf0) == 0x80) { // pict coding ext
  902. sc->interlaced = !(pkt->data[i+5] & 0x80); // progressive frame
  903. break;
  904. }
  905. } else if (c == 0x1b8) { // gop
  906. if (i + 4 < pkt->size && pkt->data[i+4]>>6 & 0x01) // closed
  907. mxf->index_entries[mxf->edit_units_count].flags |= 0x80; // random access
  908. } else if (c == 0x1b3) { // seq
  909. mxf->index_entries[mxf->edit_units_count].flags |= 0x40;
  910. } else if (c == 0x100) { // pic
  911. int pict_type = (pkt->data[i+2]>>3) & 0x07;
  912. if (pict_type == 2) { // P frame
  913. mxf->index_entries[mxf->edit_units_count].flags |= 0x22;
  914. st->codec->gop_size = 1;
  915. } else if (pict_type == 3) { // B frame
  916. mxf->index_entries[mxf->edit_units_count].flags |= 0x33;
  917. sc->temporal_reordering = -1;
  918. } else if (!pict_type) {
  919. av_log(s, AV_LOG_ERROR, "error parsing mpeg2 frame\n");
  920. return 0;
  921. }
  922. }
  923. }
  924. sc->codec_ul = mxf_get_mpeg2_codec_ul(st->codec);
  925. return !!sc->codec_ul;
  926. }
  927. static uint64_t mxf_parse_timestamp(time_t timestamp)
  928. {
  929. struct tm *time = localtime(&timestamp);
  930. return (uint64_t)(time->tm_year+1900) << 48 |
  931. (uint64_t)(time->tm_mon+1) << 40 |
  932. (uint64_t) time->tm_mday << 32 |
  933. time->tm_hour << 24 |
  934. time->tm_min << 16 |
  935. time->tm_sec << 8;
  936. }
  937. static int mxf_write_header(AVFormatContext *s)
  938. {
  939. MXFContext *mxf = s->priv_data;
  940. int i;
  941. uint8_t present[FF_ARRAY_ELEMS(mxf_essence_container_uls)] = {0};
  942. const int *samples_per_frame = NULL;
  943. if (s->nb_streams > 17) {
  944. av_log(s, AV_LOG_ERROR, "error, mxf muxer supports 17 tracks maximum\n");
  945. return -1;
  946. }
  947. for (i = 0; i < s->nb_streams; i++) {
  948. AVStream *st = s->streams[i];
  949. MXFStreamContext *sc = av_mallocz(sizeof(*sc));
  950. if (!sc)
  951. return AVERROR(ENOMEM);
  952. st->priv_data = sc;
  953. if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
  954. if (i != 0) {
  955. av_log(s, AV_LOG_ERROR, "video stream must be first track\n");
  956. return -1;
  957. }
  958. if (fabs(av_q2d(st->codec->time_base) - 1/25.0) < 0.0001) {
  959. samples_per_frame = PAL_samples_per_frame;
  960. mxf->time_base = (AVRational){ 1, 25 };
  961. } else if (fabs(av_q2d(st->codec->time_base) - 1001/30000.0) < 0.0001) {
  962. samples_per_frame = NTSC_samples_per_frame;
  963. mxf->time_base = (AVRational){ 1001, 30000 };
  964. } else {
  965. av_log(s, AV_LOG_ERROR, "unsupported video frame rate\n");
  966. return -1;
  967. }
  968. av_set_pts_info(st, 64, mxf->time_base.num, mxf->time_base.den);
  969. } else if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
  970. if (st->codec->sample_rate != 48000) {
  971. av_log(s, AV_LOG_ERROR, "only 48khz is implemented\n");
  972. return -1;
  973. }
  974. av_set_pts_info(st, 64, 1, st->codec->sample_rate);
  975. mxf->slice_count = 1;
  976. }
  977. sc->duration = -1;
  978. sc->index = mxf_get_essence_container_ul_index(st->codec->codec_id);
  979. if (sc->index == -1) {
  980. av_log(s, AV_LOG_ERROR, "track %d: could not find essence container ul, "
  981. "codec not currently supported in container\n", i);
  982. return -1;
  983. }
  984. sc->codec_ul = &mxf_essence_container_uls[sc->index].codec_ul;
  985. if (!present[sc->index]) {
  986. mxf->essence_containers_indices[mxf->essence_container_count++] = sc->index;
  987. present[sc->index] = 1;
  988. } else
  989. present[sc->index]++;
  990. memcpy(sc->track_essence_element_key, mxf_essence_container_uls[sc->index].element_ul, 15);
  991. sc->track_essence_element_key[15] = present[sc->index];
  992. PRINT_KEY(s, "track essence element key", sc->track_essence_element_key);
  993. }
  994. for (i = 0; i < s->nb_streams; i++) {
  995. MXFStreamContext *sc = s->streams[i]->priv_data;
  996. // update element count
  997. sc->track_essence_element_key[13] = present[sc->index];
  998. sc->order = AV_RB32(sc->track_essence_element_key+12);
  999. }
  1000. mxf->timestamp = mxf_parse_timestamp(s->timestamp);
  1001. if (!samples_per_frame)
  1002. samples_per_frame = PAL_samples_per_frame;
  1003. if (ff_audio_interleave_init(s, samples_per_frame, mxf->time_base) < 0)
  1004. return -1;
  1005. return 0;
  1006. }
  1007. static void mxf_write_klv_fill(AVFormatContext *s)
  1008. {
  1009. unsigned pad = klv_fill_size(url_ftell(s->pb));
  1010. if (pad) {
  1011. put_buffer(s->pb, klv_fill_key, 16);
  1012. pad -= 16;
  1013. pad -= klv_ber_length(pad);
  1014. klv_encode_ber_length(s->pb, pad);
  1015. for (; pad > 7; pad -= 8)
  1016. put_be64(s->pb, 0);
  1017. for (; pad; pad--)
  1018. put_byte(s->pb, 0);
  1019. assert(!(url_ftell(s->pb) & (KAG_SIZE-1)));
  1020. }
  1021. }
  1022. static const uint8_t system_metadata_pack_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x03,0x01,0x04,0x01,0x01,0x00 };
  1023. static const uint8_t system_metadata_package_set_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x43,0x01,0x01,0x0D,0x01,0x03,0x01,0x04,0x01,0x02,0x01 };
  1024. static uint32_t ff_framenum_to_12m_time_code(unsigned frame, int drop, int fps)
  1025. {
  1026. return (0 << 31) | // color frame flag
  1027. (0 << 30) | // drop frame flag
  1028. ( ((frame % fps) / 10) << 28) | // tens of frames
  1029. ( ((frame % fps) % 10) << 24) | // units of frames
  1030. (0 << 23) | // field phase (NTSC), b0 (PAL)
  1031. ((((frame / fps) % 60) / 10) << 20) | // tens of seconds
  1032. ((((frame / fps) % 60) % 10) << 16) | // units of seconds
  1033. (0 << 15) | // b0 (NTSC), b2 (PAL)
  1034. ((((frame / (fps * 60)) % 60) / 10) << 12) | // tens of minutes
  1035. ((((frame / (fps * 60)) % 60) % 10) << 8) | // units of minutes
  1036. (0 << 7) | // b1
  1037. (0 << 6) | // b2 (NSC), field phase (PAL)
  1038. ((((frame / (fps * 3600) % 24)) / 10) << 4) | // tens of hours
  1039. ( (frame / (fps * 3600) % 24)) % 10; // units of hours
  1040. }
  1041. static void mxf_write_system_item(AVFormatContext *s)
  1042. {
  1043. MXFContext *mxf = s->priv_data;
  1044. ByteIOContext *pb = s->pb;
  1045. unsigned fps, frame;
  1046. uint32_t time_code;
  1047. frame = mxf->edit_units_count;
  1048. // write system metadata pack
  1049. put_buffer(pb, system_metadata_pack_key, 16);
  1050. klv_encode_ber_length(pb, 57);
  1051. put_byte(pb, 0x5c); // UL, user date/time stamp, picture and sound item present
  1052. put_byte(pb, 0x04); // content package rate
  1053. put_byte(pb, 0x00); // content package type
  1054. put_be16(pb, 0x00); // channel handle
  1055. put_be16(pb, frame); // continuity count
  1056. if (mxf->essence_container_count > 1)
  1057. put_buffer(pb, multiple_desc_ul, 16);
  1058. else
  1059. put_buffer(pb, mxf_essence_container_uls[mxf->essence_containers_indices[0]].container_ul, 16);
  1060. put_byte(pb, 0);
  1061. put_be64(pb, 0);
  1062. put_be64(pb, 0); // creation date/time stamp
  1063. // XXX drop frame
  1064. if (mxf->time_base.den == 30000) fps = 30;
  1065. else fps = 25;
  1066. put_byte(pb, 0x81); // SMPTE 12M time code
  1067. time_code = ff_framenum_to_12m_time_code(frame, 0, fps);
  1068. put_be32(pb, time_code);
  1069. put_be32(pb, 0); // binary group data
  1070. put_be64(pb, 0);
  1071. // write system metadata package set
  1072. put_buffer(pb, system_metadata_package_set_key, 16);
  1073. klv_encode_ber_length(pb, 35);
  1074. put_byte(pb, 0x83); // UMID
  1075. put_be16(pb, 0x20);
  1076. mxf_write_umid(pb, SourcePackage, 0);
  1077. }
  1078. static int mxf_write_packet(AVFormatContext *s, AVPacket *pkt)
  1079. {
  1080. MXFContext *mxf = s->priv_data;
  1081. ByteIOContext *pb = s->pb;
  1082. AVStream *st = s->streams[pkt->stream_index];
  1083. MXFStreamContext *sc = st->priv_data;
  1084. if (!(mxf->edit_units_count % MXF_INDEX_CLUSTER_SIZE)) {
  1085. mxf->index_entries = av_realloc(mxf->index_entries,
  1086. (mxf->edit_units_count + MXF_INDEX_CLUSTER_SIZE)*
  1087. sizeof(*mxf->index_entries));
  1088. if (!mxf->index_entries) {
  1089. av_log(s, AV_LOG_ERROR, "could not allocate index entries\n");
  1090. return -1;
  1091. }
  1092. }
  1093. if (st->codec->codec_id == CODEC_ID_MPEG2VIDEO) {
  1094. if (!mxf_parse_mpeg2_frame(s, st, pkt)) {
  1095. av_log(s, AV_LOG_ERROR, "could not get mpeg2 profile and level\n");
  1096. return -1;
  1097. }
  1098. }
  1099. if (!mxf->header_written) {
  1100. mxf_write_partition(s, 1, 0, 0, header_open_partition_key, 1);
  1101. mxf->header_written = 1;
  1102. }
  1103. mxf_write_klv_fill(s);
  1104. if (st->index == 0) {
  1105. mxf->index_entries[mxf->edit_units_count].offset = url_ftell(pb);
  1106. mxf_write_system_item(s);
  1107. mxf_write_klv_fill(s);
  1108. mxf->edit_units_count++;
  1109. } else if (st->index == 1) {
  1110. mxf->index_entries[mxf->edit_units_count-1].slice_offset =
  1111. url_ftell(pb) - mxf->index_entries[mxf->edit_units_count-1].offset;
  1112. }
  1113. put_buffer(pb, sc->track_essence_element_key, 16); // write key
  1114. klv_encode_ber_length(pb, pkt->size); // write length
  1115. put_buffer(pb, pkt->data, pkt->size); // write value
  1116. sc->duration = FFMAX(pkt->pts + pkt->duration, sc->duration);
  1117. put_flush_packet(pb);
  1118. return 0;
  1119. }
  1120. static void mxf_write_random_index_pack(AVFormatContext *s)
  1121. {
  1122. MXFContext *mxf = s->priv_data;
  1123. ByteIOContext *pb = s->pb;
  1124. uint64_t pos = url_ftell(pb);
  1125. put_buffer(pb, random_index_pack_key, 16);
  1126. klv_encode_ber_length(pb, 28);
  1127. put_be32(pb, 1); // BodySID of header partition
  1128. put_be64(pb, 0); // offset of header partition
  1129. put_be32(pb, 0); // BodySID of footer partition
  1130. put_be64(pb, mxf->footer_partition_offset);
  1131. put_be32(pb, url_ftell(pb) - pos + 4);
  1132. }
  1133. static int mxf_write_footer(AVFormatContext *s)
  1134. {
  1135. MXFContext *mxf = s->priv_data;
  1136. ByteIOContext *pb = s->pb;
  1137. unsigned index_byte_count =
  1138. 109 + (s->nb_streams+1)*6 +
  1139. mxf->edit_units_count*(11+mxf->slice_count*4);
  1140. // add encoded ber length
  1141. index_byte_count += 16 + klv_ber_length(index_byte_count);
  1142. mxf_write_klv_fill(s);
  1143. mxf->footer_partition_offset = url_ftell(pb);
  1144. mxf_write_partition(s, 0, 2, index_byte_count, footer_partition_key, 0);
  1145. mxf_write_index_table_segment(s);
  1146. mxf_write_random_index_pack(s);
  1147. if (!url_is_streamed(s->pb)) {
  1148. url_fseek(pb, 0, SEEK_SET);
  1149. mxf_write_partition(s, 1, 0, 0, header_closed_partition_key, 1);
  1150. }
  1151. ff_audio_interleave_close(s);
  1152. mxf_free(s);
  1153. return 0;
  1154. }
  1155. static int mxf_interleave_get_packet(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush)
  1156. {
  1157. AVPacketList *pktl;
  1158. int stream_count = 0;
  1159. int streams[MAX_STREAMS];
  1160. memset(streams, 0, sizeof(streams));
  1161. pktl = s->packet_buffer;
  1162. while (pktl) {
  1163. //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
  1164. if (!streams[pktl->pkt.stream_index])
  1165. stream_count++;
  1166. streams[pktl->pkt.stream_index]++;
  1167. pktl = pktl->next;
  1168. }
  1169. if (stream_count && (s->nb_streams == stream_count || flush)) {
  1170. pktl = s->packet_buffer;
  1171. if (s->nb_streams != stream_count) {
  1172. AVPacketList *first = NULL;
  1173. // find first packet in edit unit
  1174. while (pktl) {
  1175. AVStream *st = s->streams[pktl->pkt.stream_index];
  1176. if (st->index == 0)
  1177. break;
  1178. else if (!first)
  1179. first = pktl;
  1180. pktl = pktl->next;
  1181. }
  1182. // purge packet queue
  1183. while (pktl) {
  1184. AVPacketList *next = pktl->next;
  1185. av_free_packet(&pktl->pkt);
  1186. av_freep(&pktl);
  1187. pktl = next;
  1188. }
  1189. if (!first)
  1190. goto out;
  1191. pktl = first;
  1192. }
  1193. *out = pktl->pkt;
  1194. //av_log(s, AV_LOG_DEBUG, "out st:%d dts:%lld\n", (*out).stream_index, (*out).dts);
  1195. s->packet_buffer = pktl->next;
  1196. av_freep(&pktl);
  1197. return 1;
  1198. } else {
  1199. out:
  1200. av_init_packet(out);
  1201. return 0;
  1202. }
  1203. }
  1204. static int mxf_compare_timestamps(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
  1205. {
  1206. MXFStreamContext *sc = s->streams[pkt ->stream_index]->priv_data;
  1207. MXFStreamContext *sc2 = s->streams[next->stream_index]->priv_data;
  1208. return next->dts > pkt->dts ||
  1209. (next->dts == pkt->dts && sc->order < sc2->order);
  1210. }
  1211. static int mxf_interleave(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush)
  1212. {
  1213. return ff_audio_interleave(s, out, pkt, flush,
  1214. mxf_interleave_get_packet, mxf_compare_timestamps);
  1215. }
  1216. AVOutputFormat mxf_muxer = {
  1217. "mxf",
  1218. NULL_IF_CONFIG_SMALL("Material eXchange Format"),
  1219. NULL,
  1220. "mxf",
  1221. sizeof(MXFContext),
  1222. CODEC_ID_PCM_S16LE,
  1223. CODEC_ID_MPEG2VIDEO,
  1224. mxf_write_header,
  1225. mxf_write_packet,
  1226. mxf_write_footer,
  1227. AVFMT_NOTIMESTAMPS,
  1228. NULL,
  1229. mxf_interleave,
  1230. };