Mercurial > libavformat.hg
annotate matroskaenc.c @ 5061:5ff6a72c9686 libavformat
In mov_read_packet remember the AVStream we want to demux next instead of the
MOVStreamContext. We need the AVStream anyway and it is easier to get the
MOVStreamContext from the AVStream than the other way around.
author | reimar |
---|---|
date | Wed, 24 Jun 2009 08:23:40 +0000 |
parents | 33a244b7ca65 |
children | 1406417325ea |
rev | line source |
---|---|
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
1 /* |
2495 | 2 * Matroska muxer |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
3 * Copyright (c) 2007 David Conrad |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
4 * |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
5 * This file is part of FFmpeg. |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
6 * |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
7 * FFmpeg is free software; you can redistribute it and/or |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
8 * modify it under the terms of the GNU Lesser General Public |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
9 * License as published by the Free Software Foundation; either |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
10 * version 2.1 of the License, or (at your option) any later version. |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
11 * |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
12 * FFmpeg is distributed in the hope that it will be useful, |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
15 * Lesser General Public License for more details. |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
16 * |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
17 * You should have received a copy of the GNU Lesser General Public |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
18 * License along with FFmpeg; if not, write to the Free Software |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
20 */ |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
21 |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
22 #include "avformat.h" |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
23 #include "riff.h" |
3601 | 24 #include "isom.h" |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
25 #include "matroska.h" |
2923
0fde8da65761
Use the isom avcc formatting for h264 extradata in matroska.
aurel
parents:
2771
diff
changeset
|
26 #include "avc.h" |
4581
c52d40f0a955
Share the function to write a raw FLAC header and use it in the Matroska
jbr
parents:
4578
diff
changeset
|
27 #include "flacenc.h" |
4201
7d2f3f1b68d8
Fix build: Add intreadwrite.h and bswap.h #includes where necessary.
diego
parents:
4002
diff
changeset
|
28 #include "libavutil/intreadwrite.h" |
3286 | 29 #include "libavutil/md5.h" |
30 #include "libavcodec/xiph.h" | |
3201 | 31 #include "libavcodec/mpeg4audio.h" |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
32 |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
33 typedef struct ebml_master { |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3892
diff
changeset
|
34 int64_t pos; ///< absolute offset in the file where the master's elements start |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
35 int sizebytes; ///< how many bytes were reserved for the size |
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
36 } ebml_master; |
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
37 |
2447 | 38 typedef struct mkv_seekhead_entry { |
39 unsigned int elementid; | |
40 uint64_t segmentpos; | |
41 } mkv_seekhead_entry; | |
42 | |
43 typedef struct mkv_seekhead { | |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3892
diff
changeset
|
44 int64_t filepos; |
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3892
diff
changeset
|
45 int64_t segment_offset; ///< the file offset to the beginning of the segment |
2450 | 46 int reserved_size; ///< -1 if appending to file |
2447 | 47 int max_entries; |
48 mkv_seekhead_entry *entries; | |
49 int num_entries; | |
50 } mkv_seekhead; | |
51 | |
2451 | 52 typedef struct { |
53 uint64_t pts; | |
54 int tracknum; | |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3892
diff
changeset
|
55 int64_t cluster_pos; ///< file offset of the cluster containing the block |
2451 | 56 } mkv_cuepoint; |
57 | |
58 typedef struct { | |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3892
diff
changeset
|
59 int64_t segment_offset; |
2451 | 60 mkv_cuepoint *entries; |
61 int num_entries; | |
62 } mkv_cues; | |
63 | |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
64 typedef struct MatroskaMuxContext { |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
65 ebml_master segment; |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3892
diff
changeset
|
66 int64_t segment_offset; |
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3892
diff
changeset
|
67 int64_t segment_uid; |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
68 ebml_master cluster; |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3892
diff
changeset
|
69 int64_t cluster_pos; ///< file offset of the current cluster |
2448 | 70 uint64_t cluster_pts; |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3892
diff
changeset
|
71 int64_t duration_offset; |
2448 | 72 uint64_t duration; |
2447 | 73 mkv_seekhead *main_seekhead; |
74 mkv_seekhead *cluster_seekhead; | |
2451 | 75 mkv_cues *cues; |
2479
139406606437
Use a MD5 hash of some frames to write the segment uid
conrad
parents:
2478
diff
changeset
|
76 |
139406606437
Use a MD5 hash of some frames to write the segment uid
conrad
parents:
2478
diff
changeset
|
77 struct AVMD5 *md5_ctx; |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
78 } MatroskaMuxContext; |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
79 |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
80 |
2506 | 81 /** 2 bytes * 3 for EBML IDs, 3 1-byte EBML lengths, 8 bytes for 64 bit |
82 * offset, 4 bytes for target EBML ID */ | |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
83 #define MAX_SEEKENTRY_SIZE 21 |
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
84 |
2506 | 85 /** per-cuepoint-track - 3 1-byte EBML IDs, 3 1-byte EBML sizes, 2 |
86 * 8-byte uint max */ | |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
87 #define MAX_CUETRACKPOS_SIZE 22 |
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
88 |
2506 | 89 /** per-cuepoint - 2 1-byte EBML IDs, 2 1-byte EBML sizes, 8-byte uint max */ |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
90 #define MAX_CUEPOINT_SIZE(num_tracks) 12 + MAX_CUETRACKPOS_SIZE*num_tracks |
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
91 |
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
92 |
2481 | 93 static int ebml_id_size(unsigned int id) |
94 { | |
95 return (av_log2(id+1)-1)/7+1; | |
96 } | |
97 | |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
98 static void put_ebml_id(ByteIOContext *pb, unsigned int id) |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
99 { |
2482 | 100 int i = ebml_id_size(id); |
101 while (i--) | |
102 put_byte(pb, id >> (i*8)); | |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
103 } |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
104 |
2480 | 105 /** |
2530 | 106 * Write an EBML size meaning "unknown size". |
2480 | 107 * |
2530 | 108 * @param bytes The number of bytes the size should occupy (maximum: 8). |
2480 | 109 */ |
110 static void put_ebml_size_unknown(ByteIOContext *pb, int bytes) | |
111 { | |
2497 | 112 assert(bytes <= 8); |
2496 | 113 put_byte(pb, 0x1ff >> bytes); |
114 while (--bytes) | |
115 put_byte(pb, 0xff); | |
2480 | 116 } |
117 | |
2484
60428e4e5242
Move calculating the bytes needed to represent a size in EBML to its own function
conrad
parents:
2483
diff
changeset
|
118 /** |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
119 * Calculate how many bytes are needed to represent a given number in EBML. |
2484
60428e4e5242
Move calculating the bytes needed to represent a size in EBML to its own function
conrad
parents:
2483
diff
changeset
|
120 */ |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
121 static int ebml_num_size(uint64_t num) |
2484
60428e4e5242
Move calculating the bytes needed to represent a size in EBML to its own function
conrad
parents:
2483
diff
changeset
|
122 { |
60428e4e5242
Move calculating the bytes needed to represent a size in EBML to its own function
conrad
parents:
2483
diff
changeset
|
123 int bytes = 1; |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
124 while ((num+1) >> bytes*7) bytes++; |
2484
60428e4e5242
Move calculating the bytes needed to represent a size in EBML to its own function
conrad
parents:
2483
diff
changeset
|
125 return bytes; |
60428e4e5242
Move calculating the bytes needed to represent a size in EBML to its own function
conrad
parents:
2483
diff
changeset
|
126 } |
60428e4e5242
Move calculating the bytes needed to represent a size in EBML to its own function
conrad
parents:
2483
diff
changeset
|
127 |
2487
9a9c45b95c6f
Modify put_ebml_size() so that the bytes parameter is exact rather than minimum
conrad
parents:
2486
diff
changeset
|
128 /** |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
129 * Write a number in EBML variable length format. |
2487
9a9c45b95c6f
Modify put_ebml_size() so that the bytes parameter is exact rather than minimum
conrad
parents:
2486
diff
changeset
|
130 * |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
131 * @param bytes The number of bytes that need to be used to write the number. |
2487
9a9c45b95c6f
Modify put_ebml_size() so that the bytes parameter is exact rather than minimum
conrad
parents:
2486
diff
changeset
|
132 * If zero, any number of bytes can be used. |
9a9c45b95c6f
Modify put_ebml_size() so that the bytes parameter is exact rather than minimum
conrad
parents:
2486
diff
changeset
|
133 */ |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
134 static void put_ebml_num(ByteIOContext *pb, uint64_t num, int bytes) |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
135 { |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
136 int i, needed_bytes = ebml_num_size(num); |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
137 |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
138 // sizes larger than this are currently undefined in EBML |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
139 assert(num < (1ULL<<56)-1); |
2440
69e2592531b6
Write unknown size if the size given is too large for EBML (greater than 2^56-1)
conrad
parents:
2439
diff
changeset
|
140 |
2487
9a9c45b95c6f
Modify put_ebml_size() so that the bytes parameter is exact rather than minimum
conrad
parents:
2486
diff
changeset
|
141 if (bytes == 0) |
9a9c45b95c6f
Modify put_ebml_size() so that the bytes parameter is exact rather than minimum
conrad
parents:
2486
diff
changeset
|
142 // don't care how many bytes are used, so use the min |
9a9c45b95c6f
Modify put_ebml_size() so that the bytes parameter is exact rather than minimum
conrad
parents:
2486
diff
changeset
|
143 bytes = needed_bytes; |
2498 | 144 // the bytes needed to write the given size would exceed the bytes |
145 // that we need to use, so write unknown size. This shouldn't happen. | |
2497 | 146 assert(bytes >= needed_bytes); |
2487
9a9c45b95c6f
Modify put_ebml_size() so that the bytes parameter is exact rather than minimum
conrad
parents:
2486
diff
changeset
|
147 |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
148 num |= 1ULL << bytes*7; |
2485 | 149 for (i = bytes - 1; i >= 0; i--) |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
150 put_byte(pb, num >> i*8); |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
151 } |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
152 |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
153 static void put_ebml_uint(ByteIOContext *pb, unsigned int elementid, uint64_t val) |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
154 { |
2483 | 155 int i, bytes = 1; |
3097 | 156 uint64_t tmp = val; |
157 while (tmp>>=8) bytes++; | |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
158 |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
159 put_ebml_id(pb, elementid); |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
160 put_ebml_num(pb, bytes, 0); |
2483 | 161 for (i = bytes - 1; i >= 0; i--) |
162 put_byte(pb, val >> i*8); | |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
163 } |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
164 |
2430 | 165 static void put_ebml_float(ByteIOContext *pb, unsigned int elementid, double val) |
166 { | |
167 put_ebml_id(pb, elementid); | |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
168 put_ebml_num(pb, 8, 0); |
2430 | 169 put_be64(pb, av_dbl2int(val)); |
170 } | |
171 | |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
172 static void put_ebml_binary(ByteIOContext *pb, unsigned int elementid, |
2429 | 173 const uint8_t *buf, int size) |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
174 { |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
175 put_ebml_id(pb, elementid); |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
176 put_ebml_num(pb, size, 0); |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
177 put_buffer(pb, buf, size); |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
178 } |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
179 |
2429 | 180 static void put_ebml_string(ByteIOContext *pb, unsigned int elementid, const char *str) |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
181 { |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
182 put_ebml_binary(pb, elementid, str, strlen(str)); |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
183 } |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
184 |
2477 | 185 /** |
2494 | 186 * Writes a void element of a given size. Useful for reserving space in |
187 * the file to be written to later. | |
2477 | 188 * |
2491 | 189 * @param size The number of bytes to reserve, which must be at least 2. |
2477 | 190 */ |
2442 | 191 static void put_ebml_void(ByteIOContext *pb, uint64_t size) |
192 { | |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3892
diff
changeset
|
193 int64_t currentpos = url_ftell(pb); |
2442 | 194 |
2497 | 195 assert(size >= 2); |
2442 | 196 |
197 put_ebml_id(pb, EBML_ID_VOID); | |
2494 | 198 // we need to subtract the length needed to store the size from the |
199 // size we need to reserve so 2 cases, we use 8 bytes to store the | |
200 // size if possible, 1 byte otherwise | |
2442 | 201 if (size < 10) |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
202 put_ebml_num(pb, size-1, 0); |
2442 | 203 else |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
204 put_ebml_num(pb, size-9, 8); |
2928
bdc992cb8e46
Write 0 instead of seeking forward (and leaving bytes uninitalized),
michael
parents:
2927
diff
changeset
|
205 while(url_ftell(pb) < currentpos + size) |
bdc992cb8e46
Write 0 instead of seeking forward (and leaving bytes uninitalized),
michael
parents:
2927
diff
changeset
|
206 put_byte(pb, 0); |
2442 | 207 } |
208 | |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
209 static ebml_master start_ebml_master(ByteIOContext *pb, unsigned int elementid, uint64_t expectedsize) |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
210 { |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
211 int bytes = expectedsize ? ebml_num_size(expectedsize) : 8; |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
212 put_ebml_id(pb, elementid); |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
213 put_ebml_size_unknown(pb, bytes); |
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
214 return (ebml_master){ url_ftell(pb), bytes }; |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
215 } |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
216 |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
217 static void end_ebml_master(ByteIOContext *pb, ebml_master master) |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
218 { |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3892
diff
changeset
|
219 int64_t pos = url_ftell(pb); |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
220 |
2514 | 221 // leave the unknown size for masters when streaming |
222 if (url_is_streamed(pb)) | |
223 return; | |
224 | |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
225 url_fseek(pb, master.pos - master.sizebytes, SEEK_SET); |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
226 put_ebml_num(pb, pos - master.pos, master.sizebytes); |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
227 url_fseek(pb, pos, SEEK_SET); |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
228 } |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
229 |
2469 | 230 static void put_xiph_size(ByteIOContext *pb, int size) |
231 { | |
232 int i; | |
233 for (i = 0; i < size / 255; i++) | |
234 put_byte(pb, 255); | |
235 put_byte(pb, size % 255); | |
236 } | |
237 | |
2477 | 238 /** |
2494 | 239 * Initialize a mkv_seekhead element to be ready to index level 1 Matroska |
240 * elements. If a maximum number of elements is specified, enough space | |
241 * will be reserved at the current file location to write a seek head of | |
242 * that size. | |
2477 | 243 * |
2494 | 244 * @param segment_offset The absolute offset to the position in the file |
2519 | 245 * where the segment begins. |
246 * @param numelements The maximum number of elements that will be indexed | |
2494 | 247 * by this seek head, 0 if unlimited. |
2477 | 248 */ |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3892
diff
changeset
|
249 static mkv_seekhead * mkv_start_seekhead(ByteIOContext *pb, int64_t segment_offset, int numelements) |
2447 | 250 { |
251 mkv_seekhead *new_seekhead = av_mallocz(sizeof(mkv_seekhead)); | |
252 if (new_seekhead == NULL) | |
253 return NULL; | |
254 | |
255 new_seekhead->segment_offset = segment_offset; | |
256 | |
257 if (numelements > 0) { | |
258 new_seekhead->filepos = url_ftell(pb); | |
2494 | 259 // 21 bytes max for a seek entry, 10 bytes max for the SeekHead ID |
260 // and size, and 3 bytes to guarantee that an EBML void element | |
261 // will fit afterwards | |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
262 new_seekhead->reserved_size = numelements * MAX_SEEKENTRY_SIZE + 13; |
2447 | 263 new_seekhead->max_entries = numelements; |
264 put_ebml_void(pb, new_seekhead->reserved_size); | |
265 } | |
266 return new_seekhead; | |
267 } | |
268 | |
269 static int mkv_add_seekhead_entry(mkv_seekhead *seekhead, unsigned int elementid, uint64_t filepos) | |
270 { | |
271 mkv_seekhead_entry *entries = seekhead->entries; | |
272 | |
273 // don't store more elements than we reserved space for | |
274 if (seekhead->max_entries > 0 && seekhead->max_entries <= seekhead->num_entries) | |
275 return -1; | |
276 | |
277 entries = av_realloc(entries, (seekhead->num_entries + 1) * sizeof(mkv_seekhead_entry)); | |
278 if (entries == NULL) | |
2499 | 279 return AVERROR(ENOMEM); |
2447 | 280 |
2507
048f4f45a84c
Use num_entries directly rather than mixing it with a local copy
conrad
parents:
2506
diff
changeset
|
281 entries[seekhead->num_entries ].elementid = elementid; |
048f4f45a84c
Use num_entries directly rather than mixing it with a local copy
conrad
parents:
2506
diff
changeset
|
282 entries[seekhead->num_entries++].segmentpos = filepos - seekhead->segment_offset; |
2447 | 283 |
284 seekhead->entries = entries; | |
285 return 0; | |
286 } | |
287 | |
2477 | 288 /** |
2494 | 289 * Write the seek head to the file and free it. If a maximum number of |
290 * elements was specified to mkv_start_seekhead(), the seek head will | |
291 * be written at the location reserved for it. Otherwise, it is written | |
292 * at the current location in the file. | |
2477 | 293 * |
2519 | 294 * @return The file offset where the seekhead was written. |
2477 | 295 */ |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3892
diff
changeset
|
296 static int64_t mkv_write_seekhead(ByteIOContext *pb, mkv_seekhead *seekhead) |
2447 | 297 { |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
298 ebml_master metaseek, seekentry; |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3892
diff
changeset
|
299 int64_t currentpos; |
2447 | 300 int i; |
301 | |
302 currentpos = url_ftell(pb); | |
303 | |
304 if (seekhead->reserved_size > 0) | |
305 url_fseek(pb, seekhead->filepos, SEEK_SET); | |
306 | |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
307 metaseek = start_ebml_master(pb, MATROSKA_ID_SEEKHEAD, seekhead->reserved_size); |
2447 | 308 for (i = 0; i < seekhead->num_entries; i++) { |
309 mkv_seekhead_entry *entry = &seekhead->entries[i]; | |
310 | |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
311 seekentry = start_ebml_master(pb, MATROSKA_ID_SEEKENTRY, MAX_SEEKENTRY_SIZE); |
2447 | 312 |
313 put_ebml_id(pb, MATROSKA_ID_SEEKID); | |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
314 put_ebml_num(pb, ebml_id_size(entry->elementid), 0); |
2447 | 315 put_ebml_id(pb, entry->elementid); |
316 | |
317 put_ebml_uint(pb, MATROSKA_ID_SEEKPOSITION, entry->segmentpos); | |
318 end_ebml_master(pb, seekentry); | |
319 } | |
320 end_ebml_master(pb, metaseek); | |
321 | |
322 if (seekhead->reserved_size > 0) { | |
323 uint64_t remaining = seekhead->filepos + seekhead->reserved_size - url_ftell(pb); | |
324 put_ebml_void(pb, remaining); | |
325 url_fseek(pb, currentpos, SEEK_SET); | |
326 | |
327 currentpos = seekhead->filepos; | |
328 } | |
329 av_free(seekhead->entries); | |
330 av_free(seekhead); | |
331 | |
332 return currentpos; | |
333 } | |
334 | |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3892
diff
changeset
|
335 static mkv_cues * mkv_start_cues(int64_t segment_offset) |
2451 | 336 { |
337 mkv_cues *cues = av_mallocz(sizeof(mkv_cues)); | |
338 if (cues == NULL) | |
339 return NULL; | |
340 | |
341 cues->segment_offset = segment_offset; | |
342 return cues; | |
343 } | |
344 | |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3892
diff
changeset
|
345 static int mkv_add_cuepoint(mkv_cues *cues, AVPacket *pkt, int64_t cluster_pos) |
2451 | 346 { |
347 mkv_cuepoint *entries = cues->entries; | |
348 | |
349 entries = av_realloc(entries, (cues->num_entries + 1) * sizeof(mkv_cuepoint)); | |
350 if (entries == NULL) | |
2499 | 351 return AVERROR(ENOMEM); |
2451 | 352 |
2507
048f4f45a84c
Use num_entries directly rather than mixing it with a local copy
conrad
parents:
2506
diff
changeset
|
353 entries[cues->num_entries ].pts = pkt->pts; |
048f4f45a84c
Use num_entries directly rather than mixing it with a local copy
conrad
parents:
2506
diff
changeset
|
354 entries[cues->num_entries ].tracknum = pkt->stream_index + 1; |
048f4f45a84c
Use num_entries directly rather than mixing it with a local copy
conrad
parents:
2506
diff
changeset
|
355 entries[cues->num_entries++].cluster_pos = cluster_pos - cues->segment_offset; |
2451 | 356 |
357 cues->entries = entries; | |
358 return 0; | |
359 } | |
360 | |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3892
diff
changeset
|
361 static int64_t mkv_write_cues(ByteIOContext *pb, mkv_cues *cues, int num_tracks) |
2451 | 362 { |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
363 ebml_master cues_element; |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3892
diff
changeset
|
364 int64_t currentpos; |
2451 | 365 int i, j; |
366 | |
367 currentpos = url_ftell(pb); | |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
368 cues_element = start_ebml_master(pb, MATROSKA_ID_CUES, 0); |
2451 | 369 |
370 for (i = 0; i < cues->num_entries; i++) { | |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
371 ebml_master cuepoint, track_positions; |
2451 | 372 mkv_cuepoint *entry = &cues->entries[i]; |
373 uint64_t pts = entry->pts; | |
374 | |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
375 cuepoint = start_ebml_master(pb, MATROSKA_ID_POINTENTRY, MAX_CUEPOINT_SIZE(num_tracks)); |
2451 | 376 put_ebml_uint(pb, MATROSKA_ID_CUETIME, pts); |
377 | |
378 // put all the entries from different tracks that have the exact same | |
379 // timestamp into the same CuePoint | |
380 for (j = 0; j < cues->num_entries - i && entry[j].pts == pts; j++) { | |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
381 track_positions = start_ebml_master(pb, MATROSKA_ID_CUETRACKPOSITION, MAX_CUETRACKPOS_SIZE); |
2451 | 382 put_ebml_uint(pb, MATROSKA_ID_CUETRACK , entry[j].tracknum ); |
383 put_ebml_uint(pb, MATROSKA_ID_CUECLUSTERPOSITION, entry[j].cluster_pos); | |
384 end_ebml_master(pb, track_positions); | |
385 } | |
386 i += j - 1; | |
387 end_ebml_master(pb, cuepoint); | |
388 } | |
389 end_ebml_master(pb, cues_element); | |
390 | |
391 av_free(cues->entries); | |
392 av_free(cues); | |
393 return currentpos; | |
394 } | |
395 | |
2518 | 396 static int put_xiph_codecpriv(AVFormatContext *s, ByteIOContext *pb, AVCodecContext *codec) |
2444
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
397 { |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
398 uint8_t *header_start[3]; |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
399 int header_len[3]; |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
400 int first_header_size; |
2469 | 401 int j; |
2444
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
402 |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
403 if (codec->codec_id == CODEC_ID_VORBIS) |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
404 first_header_size = 30; |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
405 else |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
406 first_header_size = 42; |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
407 |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
408 if (ff_split_xiph_headers(codec->extradata, codec->extradata_size, |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
409 first_header_size, header_start, header_len) < 0) { |
2518 | 410 av_log(s, AV_LOG_ERROR, "Extradata corrupt.\n"); |
2444
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
411 return -1; |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
412 } |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
413 |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
414 put_byte(pb, 2); // number packets - 1 |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
415 for (j = 0; j < 2; j++) { |
2469 | 416 put_xiph_size(pb, header_len[j]); |
2444
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
417 } |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
418 for (j = 0; j < 3; j++) |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
419 put_buffer(pb, header_start[j], header_len[j]); |
2446
b2f9523ee424
Make sure to return a value in functions that return a value
conrad
parents:
2445
diff
changeset
|
420 |
b2f9523ee424
Make sure to return a value in functions that return a value
conrad
parents:
2445
diff
changeset
|
421 return 0; |
2444
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
422 } |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
423 |
2518 | 424 static void get_aac_sample_rates(AVFormatContext *s, AVCodecContext *codec, int *sample_rate, int *output_sample_rate) |
2458
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
425 { |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
426 int sri; |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
427 |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
428 if (codec->extradata_size < 2) { |
2519 | 429 av_log(s, AV_LOG_WARNING, "No AAC extradata, unable to determine samplerate.\n"); |
2458
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
430 return; |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
431 } |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
432 |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
433 sri = ((codec->extradata[0] << 1) & 0xE) | (codec->extradata[1] >> 7); |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
434 if (sri > 12) { |
2518 | 435 av_log(s, AV_LOG_WARNING, "AAC samplerate index out of bounds\n"); |
2458
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
436 return; |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
437 } |
3201 | 438 *sample_rate = ff_mpeg4audio_sample_rates[sri]; |
2458
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
439 |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
440 // if sbr, get output sample rate as well |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
441 if (codec->extradata_size == 5) { |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
442 sri = (codec->extradata[4] >> 3) & 0xF; |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
443 if (sri > 12) { |
2518 | 444 av_log(s, AV_LOG_WARNING, "AAC output samplerate index out of bounds\n"); |
2458
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
445 return; |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
446 } |
3201 | 447 *output_sample_rate = ff_mpeg4audio_sample_rates[sri]; |
2458
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
448 } |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
449 } |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
450 |
3601 | 451 static int mkv_write_codecprivate(AVFormatContext *s, ByteIOContext *pb, AVCodecContext *codec, int native_id, int qt_id) |
2509
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
452 { |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
453 ByteIOContext *dyn_cp; |
2510
4ba8d5f648a4
Write codecprivate to a dynamic buffer so that seeking isn't required
conrad
parents:
2509
diff
changeset
|
454 uint8_t *codecpriv; |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
455 int ret, codecpriv_size; |
2510
4ba8d5f648a4
Write codecprivate to a dynamic buffer so that seeking isn't required
conrad
parents:
2509
diff
changeset
|
456 |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
457 ret = url_open_dyn_buf(&dyn_cp); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
458 if(ret < 0) |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
459 return ret; |
2509
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
460 |
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
461 if (native_id) { |
2513 | 462 if (codec->codec_id == CODEC_ID_VORBIS || codec->codec_id == CODEC_ID_THEORA) |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
463 ret = put_xiph_codecpriv(s, dyn_cp, codec); |
2513 | 464 else if (codec->codec_id == CODEC_ID_FLAC) |
4581
c52d40f0a955
Share the function to write a raw FLAC header and use it in the Matroska
jbr
parents:
4578
diff
changeset
|
465 ret = ff_flac_write_header(dyn_cp, codec); |
2923
0fde8da65761
Use the isom avcc formatting for h264 extradata in matroska.
aurel
parents:
2771
diff
changeset
|
466 else if (codec->codec_id == CODEC_ID_H264) |
2927
b75a49790f31
add a ff_ prefix to newly exported functions from avc.c
aurel
parents:
2926
diff
changeset
|
467 ret = ff_isom_write_avcc(dyn_cp, codec->extradata, codec->extradata_size); |
2513 | 468 else if (codec->extradata_size) |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
469 put_buffer(dyn_cp, codec->extradata, codec->extradata_size); |
2509
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
470 } else if (codec->codec_type == CODEC_TYPE_VIDEO) { |
3601 | 471 if (qt_id) { |
472 if (!codec->codec_tag) | |
5058
33a244b7ca65
Add ff_ prefixes to exported symbols in libavformat/riff.h.
diego
parents:
4581
diff
changeset
|
473 codec->codec_tag = ff_codec_get_tag(codec_movvideo_tags, codec->codec_id); |
3601 | 474 if (codec->extradata_size) |
475 put_buffer(dyn_cp, codec->extradata, codec->extradata_size); | |
476 } else { | |
2509
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
477 if (!codec->codec_tag) |
5058
33a244b7ca65
Add ff_ prefixes to exported symbols in libavformat/riff.h.
diego
parents:
4581
diff
changeset
|
478 codec->codec_tag = ff_codec_get_tag(ff_codec_bmp_tags, codec->codec_id); |
2511
0ca390638aa5
Match the behaviour betwen the bmp and wav codec tag lookups
conrad
parents:
2510
diff
changeset
|
479 if (!codec->codec_tag) { |
2519 | 480 av_log(s, AV_LOG_ERROR, "No bmp codec ID found."); |
2511
0ca390638aa5
Match the behaviour betwen the bmp and wav codec tag lookups
conrad
parents:
2510
diff
changeset
|
481 ret = -1; |
0ca390638aa5
Match the behaviour betwen the bmp and wav codec tag lookups
conrad
parents:
2510
diff
changeset
|
482 } |
2509
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
483 |
5058
33a244b7ca65
Add ff_ prefixes to exported symbols in libavformat/riff.h.
diego
parents:
4581
diff
changeset
|
484 ff_put_bmp_header(dyn_cp, codec, ff_codec_bmp_tags, 0); |
3601 | 485 } |
2509
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
486 |
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
487 } else if (codec->codec_type == CODEC_TYPE_AUDIO) { |
2511
0ca390638aa5
Match the behaviour betwen the bmp and wav codec tag lookups
conrad
parents:
2510
diff
changeset
|
488 if (!codec->codec_tag) |
5058
33a244b7ca65
Add ff_ prefixes to exported symbols in libavformat/riff.h.
diego
parents:
4581
diff
changeset
|
489 codec->codec_tag = ff_codec_get_tag(ff_codec_wav_tags, codec->codec_id); |
2509
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
490 if (!codec->codec_tag) { |
2519 | 491 av_log(s, AV_LOG_ERROR, "No wav codec ID found."); |
2510
4ba8d5f648a4
Write codecprivate to a dynamic buffer so that seeking isn't required
conrad
parents:
2509
diff
changeset
|
492 ret = -1; |
2509
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
493 } |
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
494 |
5058
33a244b7ca65
Add ff_ prefixes to exported symbols in libavformat/riff.h.
diego
parents:
4581
diff
changeset
|
495 ff_put_wav_header(dyn_cp, codec); |
2509
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
496 } |
2510
4ba8d5f648a4
Write codecprivate to a dynamic buffer so that seeking isn't required
conrad
parents:
2509
diff
changeset
|
497 |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
498 codecpriv_size = url_close_dyn_buf(dyn_cp, &codecpriv); |
2510
4ba8d5f648a4
Write codecprivate to a dynamic buffer so that seeking isn't required
conrad
parents:
2509
diff
changeset
|
499 if (codecpriv_size) |
4ba8d5f648a4
Write codecprivate to a dynamic buffer so that seeking isn't required
conrad
parents:
2509
diff
changeset
|
500 put_ebml_binary(pb, MATROSKA_ID_CODECPRIVATE, codecpriv, codecpriv_size); |
4ba8d5f648a4
Write codecprivate to a dynamic buffer so that seeking isn't required
conrad
parents:
2509
diff
changeset
|
501 av_free(codecpriv); |
4ba8d5f648a4
Write codecprivate to a dynamic buffer so that seeking isn't required
conrad
parents:
2509
diff
changeset
|
502 return ret; |
2509
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
503 } |
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
504 |
2445
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
505 static int mkv_write_tracks(AVFormatContext *s) |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
506 { |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
507 MatroskaMuxContext *mkv = s->priv_data; |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
508 ByteIOContext *pb = s->pb; |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
509 ebml_master tracks; |
2501 | 510 int i, j, ret; |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
511 |
2501 | 512 ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_TRACKS, url_ftell(pb)); |
513 if (ret < 0) return ret; | |
2447 | 514 |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
515 tracks = start_ebml_master(pb, MATROSKA_ID_TRACKS, 0); |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
516 for (i = 0; i < s->nb_streams; i++) { |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
517 AVStream *st = s->streams[i]; |
2432
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
518 AVCodecContext *codec = st->codec; |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
519 ebml_master subinfo, track; |
2432
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
520 int native_id = 0; |
3601 | 521 int qt_id = 0; |
2454 | 522 int bit_depth = av_get_bits_per_sample(codec->codec_id); |
2458
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
523 int sample_rate = codec->sample_rate; |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
524 int output_sample_rate = 0; |
4498 | 525 AVMetadataTag *tag; |
2458
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
526 |
2493
61bc7a789851
Use sample format for bit depth if av_get_bits_per_sample() doesn't give one
conrad
parents:
2492
diff
changeset
|
527 if (!bit_depth) |
61bc7a789851
Use sample format for bit depth if av_get_bits_per_sample() doesn't give one
conrad
parents:
2492
diff
changeset
|
528 bit_depth = av_get_bits_per_sample_format(codec->sample_fmt); |
61bc7a789851
Use sample format for bit depth if av_get_bits_per_sample() doesn't give one
conrad
parents:
2492
diff
changeset
|
529 |
2458
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
530 if (codec->codec_id == CODEC_ID_AAC) |
2518 | 531 get_aac_sample_rates(s, codec, &sample_rate, &output_sample_rate); |
2432
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
532 |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
533 track = start_ebml_master(pb, MATROSKA_ID_TRACKENTRY, 0); |
2439 | 534 put_ebml_uint (pb, MATROSKA_ID_TRACKNUMBER , i + 1); |
535 put_ebml_uint (pb, MATROSKA_ID_TRACKUID , i + 1); | |
2432
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
536 put_ebml_uint (pb, MATROSKA_ID_TRACKFLAGLACING , 0); // no lacing (yet) |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
537 |
4498 | 538 if ((tag = av_metadata_get(st->metadata, "description", NULL, 0))) |
539 put_ebml_string(pb, MATROSKA_ID_TRACKNAME, tag->value); | |
540 tag = av_metadata_get(st->metadata, "language", NULL, 0); | |
541 put_ebml_string(pb, MATROSKA_ID_TRACKLANGUAGE, tag ? tag->value:"und"); | |
2432
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
542 |
4240
dff232a64d7c
Treat disposition==0 as undefined and don't write the default flag
conrad
parents:
4239
diff
changeset
|
543 if (st->disposition) |
4241 | 544 put_ebml_uint(pb, MATROSKA_ID_TRACKFLAGDEFAULT, !!(st->disposition & AV_DISPOSITION_DEFAULT)); |
3120
ea5623a8efde
Add 'disposition' bitfield to AVStream and use it for both muxing and demuxing
eugeni
parents:
3097
diff
changeset
|
545 |
2519 | 546 // look for a codec ID string specific to mkv to use, |
2494 | 547 // if none are found, use AVI codes |
2432
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
548 for (j = 0; ff_mkv_codec_tags[j].id != CODEC_ID_NONE; j++) { |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
549 if (ff_mkv_codec_tags[j].id == codec->codec_id) { |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
550 put_ebml_string(pb, MATROSKA_ID_CODECID, ff_mkv_codec_tags[j].str); |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
551 native_id = 1; |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
552 break; |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
553 } |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
554 } |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
555 |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
556 switch (codec->codec_type) { |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
557 case CODEC_TYPE_VIDEO: |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
558 put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, MATROSKA_TRACK_TYPE_VIDEO); |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
559 |
3601 | 560 if (!native_id && |
5058
33a244b7ca65
Add ff_ prefixes to exported symbols in libavformat/riff.h.
diego
parents:
4581
diff
changeset
|
561 ff_codec_get_tag(codec_movvideo_tags, codec->codec_id) && |
33a244b7ca65
Add ff_ prefixes to exported symbols in libavformat/riff.h.
diego
parents:
4581
diff
changeset
|
562 (!ff_codec_get_tag(ff_codec_bmp_tags, codec->codec_id) |
3601 | 563 || codec->codec_id == CODEC_ID_SVQ1 |
564 || codec->codec_id == CODEC_ID_SVQ3 | |
565 || codec->codec_id == CODEC_ID_CINEPAK)) | |
566 qt_id = 1; | |
567 | |
568 if (qt_id) | |
569 put_ebml_string(pb, MATROSKA_ID_CODECID, "V_QUICKTIME"); | |
570 else if (!native_id) | |
2519 | 571 // if there is no mkv-specific codec ID, use VFW mode |
3687
494a55f131f3
matroska: expand useless define for MS compat codec id strings
aurel
parents:
3601
diff
changeset
|
572 put_ebml_string(pb, MATROSKA_ID_CODECID, "V_MS/VFW/FOURCC"); |
2513 | 573 |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
574 subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKVIDEO, 0); |
2432
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
575 // XXX: interlace flag? |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
576 put_ebml_uint (pb, MATROSKA_ID_VIDEOPIXELWIDTH , codec->width); |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
577 put_ebml_uint (pb, MATROSKA_ID_VIDEOPIXELHEIGHT, codec->height); |
3759
27537074f2a9
convert every muxer/demuxer to write/read sample_aspect_ratio from/to
aurel
parents:
3692
diff
changeset
|
578 if (st->sample_aspect_ratio.num) { |
27537074f2a9
convert every muxer/demuxer to write/read sample_aspect_ratio from/to
aurel
parents:
3692
diff
changeset
|
579 int d_width = codec->width*av_q2d(st->sample_aspect_ratio); |
27537074f2a9
convert every muxer/demuxer to write/read sample_aspect_ratio from/to
aurel
parents:
3692
diff
changeset
|
580 put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH , d_width); |
27537074f2a9
convert every muxer/demuxer to write/read sample_aspect_ratio from/to
aurel
parents:
3692
diff
changeset
|
581 put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, codec->height); |
2473 | 582 } |
2432
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
583 end_ebml_master(pb, subinfo); |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
584 break; |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
585 |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
586 case CODEC_TYPE_AUDIO: |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
587 put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, MATROSKA_TRACK_TYPE_AUDIO); |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
588 |
2513 | 589 if (!native_id) |
2452
1b6ea48f7f24
Write wav header if there is no native audio codec ID
conrad
parents:
2451
diff
changeset
|
590 // no mkv-specific ID, use ACM mode |
3687
494a55f131f3
matroska: expand useless define for MS compat codec id strings
aurel
parents:
3601
diff
changeset
|
591 put_ebml_string(pb, MATROSKA_ID_CODECID, "A_MS/ACM"); |
2513 | 592 |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
593 subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKAUDIO, 0); |
2432
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
594 put_ebml_uint (pb, MATROSKA_ID_AUDIOCHANNELS , codec->channels); |
2458
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
595 put_ebml_float (pb, MATROSKA_ID_AUDIOSAMPLINGFREQ, sample_rate); |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
596 if (output_sample_rate) |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
597 put_ebml_float(pb, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, output_sample_rate); |
2453 | 598 if (bit_depth) |
599 put_ebml_uint(pb, MATROSKA_ID_AUDIOBITDEPTH, bit_depth); | |
2432
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
600 end_ebml_master(pb, subinfo); |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
601 break; |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
602 |
2498 | 603 case CODEC_TYPE_SUBTITLE: |
604 put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, MATROSKA_TRACK_TYPE_SUBTITLE); | |
605 break; | |
2432
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
606 default: |
2503 | 607 av_log(s, AV_LOG_ERROR, "Only audio, video, and subtitles are supported for Matroska."); |
2432
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
608 break; |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
609 } |
3601 | 610 ret = mkv_write_codecprivate(s, pb, codec, native_id, qt_id); |
2509
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
611 if (ret < 0) return ret; |
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
612 |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
613 end_ebml_master(pb, track); |
2432
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
614 |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
615 // ms precision is the de-facto standard timescale for mkv files |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
616 av_set_pts_info(st, 64, 1, 1000); |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
617 } |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
618 end_ebml_master(pb, tracks); |
2446
b2f9523ee424
Make sure to return a value in functions that return a value
conrad
parents:
2445
diff
changeset
|
619 return 0; |
2445
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
620 } |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
621 |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
622 static int mkv_write_header(AVFormatContext *s) |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
623 { |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
624 MatroskaMuxContext *mkv = s->priv_data; |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
625 ByteIOContext *pb = s->pb; |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
626 ebml_master ebml_header, segment_info; |
4498 | 627 AVMetadataTag *tag; |
2501 | 628 int ret; |
2445
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
629 |
2479
139406606437
Use a MD5 hash of some frames to write the segment uid
conrad
parents:
2478
diff
changeset
|
630 mkv->md5_ctx = av_mallocz(av_md5_size); |
139406606437
Use a MD5 hash of some frames to write the segment uid
conrad
parents:
2478
diff
changeset
|
631 av_md5_init(mkv->md5_ctx); |
139406606437
Use a MD5 hash of some frames to write the segment uid
conrad
parents:
2478
diff
changeset
|
632 |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
633 ebml_header = start_ebml_master(pb, EBML_ID_HEADER, 0); |
2445
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
634 put_ebml_uint (pb, EBML_ID_EBMLVERSION , 1); |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
635 put_ebml_uint (pb, EBML_ID_EBMLREADVERSION , 1); |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
636 put_ebml_uint (pb, EBML_ID_EBMLMAXIDLENGTH , 4); |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
637 put_ebml_uint (pb, EBML_ID_EBMLMAXSIZELENGTH , 8); |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
638 put_ebml_string (pb, EBML_ID_DOCTYPE , "matroska"); |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
639 put_ebml_uint (pb, EBML_ID_DOCTYPEVERSION , 2); |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
640 put_ebml_uint (pb, EBML_ID_DOCTYPEREADVERSION , 2); |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
641 end_ebml_master(pb, ebml_header); |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
642 |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
643 mkv->segment = start_ebml_master(pb, MATROSKA_ID_SEGMENT, 0); |
2447 | 644 mkv->segment_offset = url_ftell(pb); |
645 | |
2494 | 646 // we write 2 seek heads - one at the end of the file to point to each |
647 // cluster, and one at the beginning to point to all other level one | |
648 // elements (including the seek head at the end of the file), which | |
649 // isn't more than 10 elements if we only write one of each other | |
650 // currently defined level 1 element | |
2447 | 651 mkv->main_seekhead = mkv_start_seekhead(pb, mkv->segment_offset, 10); |
652 mkv->cluster_seekhead = mkv_start_seekhead(pb, mkv->segment_offset, 0); | |
2500 | 653 if (mkv->main_seekhead == NULL || mkv->cluster_seekhead == NULL) |
654 return AVERROR(ENOMEM); | |
2447 | 655 |
2501 | 656 ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_INFO, url_ftell(pb)); |
657 if (ret < 0) return ret; | |
2445
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
658 |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
659 segment_info = start_ebml_master(pb, MATROSKA_ID_INFO, 0); |
2445
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
660 put_ebml_uint(pb, MATROSKA_ID_TIMECODESCALE, 1000000); |
4498 | 661 if ((tag = av_metadata_get(s->metadata, "title", NULL, 0))) |
662 put_ebml_string(pb, MATROSKA_ID_TITLE, tag->value); | |
2445
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
663 if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) { |
2466 | 664 put_ebml_string(pb, MATROSKA_ID_MUXINGAPP , LIBAVFORMAT_IDENT); |
2445
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
665 put_ebml_string(pb, MATROSKA_ID_WRITINGAPP, LIBAVFORMAT_IDENT); |
2479
139406606437
Use a MD5 hash of some frames to write the segment uid
conrad
parents:
2478
diff
changeset
|
666 |
139406606437
Use a MD5 hash of some frames to write the segment uid
conrad
parents:
2478
diff
changeset
|
667 // reserve space to write the segment UID later |
139406606437
Use a MD5 hash of some frames to write the segment uid
conrad
parents:
2478
diff
changeset
|
668 mkv->segment_uid = url_ftell(pb); |
139406606437
Use a MD5 hash of some frames to write the segment uid
conrad
parents:
2478
diff
changeset
|
669 put_ebml_void(pb, 19); |
2445
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
670 } |
2468 | 671 |
2445
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
672 // reserve space for the duration |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
673 mkv->duration = 0; |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
674 mkv->duration_offset = url_ftell(pb); |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
675 put_ebml_void(pb, 11); // assumes double-precision float to be written |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
676 end_ebml_master(pb, segment_info); |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
677 |
2501 | 678 ret = mkv_write_tracks(s); |
679 if (ret < 0) return ret; | |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
680 |
2501 | 681 ret = mkv_add_seekhead_entry(mkv->cluster_seekhead, MATROSKA_ID_CLUSTER, url_ftell(pb)); |
682 if (ret < 0) return ret; | |
2447 | 683 |
2451 | 684 mkv->cluster_pos = url_ftell(pb); |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
685 mkv->cluster = start_ebml_master(pb, MATROSKA_ID_CLUSTER, 0); |
2433
0c047310f205
Write one cluster and SimpleBlocks for the frames. Should now create playable mkv files for some video codecs (H.264 and VP3 checked)
conrad
parents:
2432
diff
changeset
|
686 put_ebml_uint(pb, MATROSKA_ID_CLUSTERTIMECODE, 0); |
2437 | 687 mkv->cluster_pts = 0; |
2433
0c047310f205
Write one cluster and SimpleBlocks for the frames. Should now create playable mkv files for some video codecs (H.264 and VP3 checked)
conrad
parents:
2432
diff
changeset
|
688 |
2451 | 689 mkv->cues = mkv_start_cues(mkv->segment_offset); |
690 if (mkv->cues == NULL) | |
2499 | 691 return AVERROR(ENOMEM); |
2451 | 692 |
4239
5d0ac4d87ba1
Flush the buffer after writing the header and when done with writing the files
conrad
parents:
4223
diff
changeset
|
693 put_flush_packet(pb); |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
694 return 0; |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
695 } |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
696 |
3986
2a7d8acde051
matroskaenc: pass the packet size directly as parameter of mkv_blockgroup_size()
aurel
parents:
3985
diff
changeset
|
697 static int mkv_blockgroup_size(int pkt_size) |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
698 { |
3986
2a7d8acde051
matroskaenc: pass the packet size directly as parameter of mkv_blockgroup_size()
aurel
parents:
3985
diff
changeset
|
699 int size = pkt_size + 4; |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
700 size += ebml_num_size(size); |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
701 size += 2; // EBML ID for block and block duration |
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
702 size += 8; // max size of block duration |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
703 size += ebml_num_size(size); |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
704 size += 1; // blockgroup EBML ID |
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
705 return size; |
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
706 } |
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
707 |
3988 | 708 static int ass_get_duration(const uint8_t *p) |
709 { | |
710 int sh, sm, ss, sc, eh, em, es, ec; | |
711 uint64_t start, end; | |
712 | |
713 if (sscanf(p, "%*[^,],%d:%d:%d%*c%d,%d:%d:%d%*c%d", | |
714 &sh, &sm, &ss, &sc, &eh, &em, &es, &ec) != 8) | |
715 return 0; | |
716 start = 3600000*sh + 60000*sm + 1000*ss + 10*sc; | |
717 end = 3600000*eh + 60000*em + 1000*es + 10*ec; | |
718 return end - start; | |
719 } | |
720 | |
721 static int mkv_write_ass_blocks(AVFormatContext *s, AVPacket *pkt) | |
722 { | |
723 MatroskaMuxContext *mkv = s->priv_data; | |
724 ByteIOContext *pb = s->pb; | |
725 int i, layer = 0, max_duration = 0, size, line_size, data_size = pkt->size; | |
726 uint8_t *start, *end, *data = pkt->data; | |
727 ebml_master blockgroup; | |
728 char buffer[2048]; | |
729 | |
730 while (data_size) { | |
731 int duration = ass_get_duration(data); | |
732 max_duration = FFMAX(duration, max_duration); | |
733 end = memchr(data, '\n', data_size); | |
734 size = line_size = end ? end-data+1 : data_size; | |
735 size -= end ? (end[-1]=='\r')+1 : 0; | |
736 start = data; | |
737 for (i=0; i<3; i++, start++) | |
738 if (!(start = memchr(start, ',', size-(start-data)))) | |
739 return max_duration; | |
740 size -= start - data; | |
741 sscanf(data, "Dialogue: %d,", &layer); | |
742 i = snprintf(buffer, sizeof(buffer), "%"PRId64",%d,", | |
743 s->streams[pkt->stream_index]->nb_frames++, layer); | |
744 size = FFMIN(i+size, sizeof(buffer)); | |
745 memcpy(buffer+i, start, size-i); | |
746 | |
747 av_log(s, AV_LOG_DEBUG, "Writing block at offset %" PRIu64 ", size %d, " | |
748 "pts %" PRId64 ", duration %d\n", | |
749 url_ftell(pb), size, pkt->pts, duration); | |
750 blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, mkv_blockgroup_size(size)); | |
751 put_ebml_id(pb, MATROSKA_ID_BLOCK); | |
752 put_ebml_num(pb, size+4, 0); | |
753 put_byte(pb, 0x80 | (pkt->stream_index + 1)); // this assumes stream_index is less than 126 | |
754 put_be16(pb, pkt->pts - mkv->cluster_pts); | |
755 put_byte(pb, 0); | |
756 put_buffer(pb, buffer, size); | |
757 put_ebml_uint(pb, MATROSKA_ID_BLOCKDURATION, duration); | |
758 end_ebml_master(pb, blockgroup); | |
759 | |
760 data += line_size; | |
761 data_size -= line_size; | |
762 } | |
763 | |
764 return max_duration; | |
765 } | |
766 | |
2460 | 767 static void mkv_write_block(AVFormatContext *s, unsigned int blockid, AVPacket *pkt, int flags) |
768 { | |
769 MatroskaMuxContext *mkv = s->priv_data; | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
770 ByteIOContext *pb = s->pb; |
4222
0267c4299992
Do not reallocate AVPacket's data when muxing a packet
lucabe
parents:
4201
diff
changeset
|
771 AVCodecContext *codec = s->streams[pkt->stream_index]->codec; |
4256
3f5d00cb1f61
matroskaenc: correctly handle h264 streams with 3 bytes nal startcodes
aurel
parents:
4241
diff
changeset
|
772 uint8_t *data = NULL; |
3f5d00cb1f61
matroskaenc: correctly handle h264 streams with 3 bytes nal startcodes
aurel
parents:
4241
diff
changeset
|
773 int size = pkt->size; |
2460 | 774 |
2504 | 775 av_log(s, AV_LOG_DEBUG, "Writing block at offset %" PRIu64 ", size %d, " |
776 "pts %" PRId64 ", dts %" PRId64 ", duration %d, flags %d\n", | |
2474 | 777 url_ftell(pb), pkt->size, pkt->pts, pkt->dts, pkt->duration, flags); |
4256
3f5d00cb1f61
matroskaenc: correctly handle h264 streams with 3 bytes nal startcodes
aurel
parents:
4241
diff
changeset
|
778 if (codec->codec_id == CODEC_ID_H264 && codec->extradata_size > 0 && |
3f5d00cb1f61
matroskaenc: correctly handle h264 streams with 3 bytes nal startcodes
aurel
parents:
4241
diff
changeset
|
779 (AV_RB24(codec->extradata) == 1 || AV_RB32(codec->extradata) == 1)) |
3f5d00cb1f61
matroskaenc: correctly handle h264 streams with 3 bytes nal startcodes
aurel
parents:
4241
diff
changeset
|
780 ff_avc_parse_nal_units_buf(pkt->data, &data, &size); |
3f5d00cb1f61
matroskaenc: correctly handle h264 streams with 3 bytes nal startcodes
aurel
parents:
4241
diff
changeset
|
781 else |
3f5d00cb1f61
matroskaenc: correctly handle h264 streams with 3 bytes nal startcodes
aurel
parents:
4241
diff
changeset
|
782 data = pkt->data; |
2460 | 783 put_ebml_id(pb, blockid); |
4256
3f5d00cb1f61
matroskaenc: correctly handle h264 streams with 3 bytes nal startcodes
aurel
parents:
4241
diff
changeset
|
784 put_ebml_num(pb, size+4, 0); |
2460 | 785 put_byte(pb, 0x80 | (pkt->stream_index + 1)); // this assumes stream_index is less than 126 |
786 put_be16(pb, pkt->pts - mkv->cluster_pts); | |
787 put_byte(pb, flags); | |
4256
3f5d00cb1f61
matroskaenc: correctly handle h264 streams with 3 bytes nal startcodes
aurel
parents:
4241
diff
changeset
|
788 put_buffer(pb, data, size); |
3f5d00cb1f61
matroskaenc: correctly handle h264 streams with 3 bytes nal startcodes
aurel
parents:
4241
diff
changeset
|
789 if (data != pkt->data) |
3f5d00cb1f61
matroskaenc: correctly handle h264 streams with 3 bytes nal startcodes
aurel
parents:
4241
diff
changeset
|
790 av_free(data); |
2460 | 791 } |
792 | |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
793 static int mkv_write_packet(AVFormatContext *s, AVPacket *pkt) |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
794 { |
2437 | 795 MatroskaMuxContext *mkv = s->priv_data; |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
796 ByteIOContext *pb = s->pb; |
2463 | 797 AVCodecContext *codec = s->streams[pkt->stream_index]->codec; |
2455 | 798 int keyframe = !!(pkt->flags & PKT_FLAG_KEY); |
3892
8f1928b41f45
matroska: subtitle display duration must be stored in pkt->convergence_duration
aurel
parents:
3766
diff
changeset
|
799 int duration = pkt->duration; |
2501 | 800 int ret; |
2433
0c047310f205
Write one cluster and SimpleBlocks for the frames. Should now create playable mkv files for some video codecs (H.264 and VP3 checked)
conrad
parents:
2432
diff
changeset
|
801 |
2437 | 802 // start a new cluster every 5 MB or 5 sec |
2488 | 803 if (url_ftell(pb) > mkv->cluster_pos + 5*1024*1024 || pkt->pts > mkv->cluster_pts + 5000) { |
2504 | 804 av_log(s, AV_LOG_DEBUG, "Starting new cluster at offset %" PRIu64 |
805 " bytes, pts %" PRIu64 "\n", url_ftell(pb), pkt->pts); | |
2437 | 806 end_ebml_master(pb, mkv->cluster); |
2447 | 807 |
2501 | 808 ret = mkv_add_seekhead_entry(mkv->cluster_seekhead, MATROSKA_ID_CLUSTER, url_ftell(pb)); |
809 if (ret < 0) return ret; | |
2447 | 810 |
2451 | 811 mkv->cluster_pos = url_ftell(pb); |
2489
3ef5728030da
Calculate the size of key EBML master elements beforehand so only just enough size is reserved for the size
conrad
parents:
2488
diff
changeset
|
812 mkv->cluster = start_ebml_master(pb, MATROSKA_ID_CLUSTER, 0); |
2437 | 813 put_ebml_uint(pb, MATROSKA_ID_CLUSTERTIMECODE, pkt->pts); |
814 mkv->cluster_pts = pkt->pts; | |
2479
139406606437
Use a MD5 hash of some frames to write the segment uid
conrad
parents:
2478
diff
changeset
|
815 av_md5_update(mkv->md5_ctx, pkt->data, FFMIN(200, pkt->size)); |
2437 | 816 } |
817 | |
2463 | 818 if (codec->codec_type != CODEC_TYPE_SUBTITLE) { |
2462 | 819 mkv_write_block(s, MATROSKA_ID_SIMPLEBLOCK, pkt, keyframe << 7); |
3988 | 820 } else if (codec->codec_id == CODEC_ID_SSA) { |
821 duration = mkv_write_ass_blocks(s, pkt); | |
2461 | 822 } else { |
3986
2a7d8acde051
matroskaenc: pass the packet size directly as parameter of mkv_blockgroup_size()
aurel
parents:
3985
diff
changeset
|
823 ebml_master blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, mkv_blockgroup_size(pkt->size)); |
3892
8f1928b41f45
matroska: subtitle display duration must be stored in pkt->convergence_duration
aurel
parents:
3766
diff
changeset
|
824 duration = pkt->convergence_duration; |
2461 | 825 mkv_write_block(s, MATROSKA_ID_BLOCK, pkt, 0); |
3987 | 826 put_ebml_uint(pb, MATROSKA_ID_BLOCKDURATION, duration); |
2461 | 827 end_ebml_master(pb, blockgroup); |
828 } | |
2443 | 829 |
2463 | 830 if (codec->codec_type == CODEC_TYPE_VIDEO && keyframe) { |
2501 | 831 ret = mkv_add_cuepoint(mkv->cues, pkt, mkv->cluster_pos); |
832 if (ret < 0) return ret; | |
2451 | 833 } |
834 | |
3892
8f1928b41f45
matroska: subtitle display duration must be stored in pkt->convergence_duration
aurel
parents:
3766
diff
changeset
|
835 mkv->duration = FFMAX(mkv->duration, pkt->pts + duration); |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
836 return 0; |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
837 } |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
838 |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
839 static int mkv_write_trailer(AVFormatContext *s) |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
840 { |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
841 MatroskaMuxContext *mkv = s->priv_data; |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
842 ByteIOContext *pb = s->pb; |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3892
diff
changeset
|
843 int64_t currentpos, second_seekhead, cuespos; |
2502 | 844 int ret; |
2443 | 845 |
2433
0c047310f205
Write one cluster and SimpleBlocks for the frames. Should now create playable mkv files for some video codecs (H.264 and VP3 checked)
conrad
parents:
2432
diff
changeset
|
846 end_ebml_master(pb, mkv->cluster); |
2443 | 847 |
2514 | 848 if (!url_is_streamed(pb)) { |
2515 | 849 cuespos = mkv_write_cues(pb, mkv->cues, s->nb_streams); |
850 second_seekhead = mkv_write_seekhead(pb, mkv->cluster_seekhead); | |
2451 | 851 |
2515 | 852 ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_CUES , cuespos); |
853 if (ret < 0) return ret; | |
854 ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_SEEKHEAD, second_seekhead); | |
855 if (ret < 0) return ret; | |
856 mkv_write_seekhead(pb, mkv->main_seekhead); | |
2447 | 857 |
2515 | 858 // update the duration |
859 av_log(s, AV_LOG_DEBUG, "end duration = %" PRIu64 "\n", mkv->duration); | |
860 currentpos = url_ftell(pb); | |
861 url_fseek(pb, mkv->duration_offset, SEEK_SET); | |
862 put_ebml_float(pb, MATROSKA_ID_DURATION, mkv->duration); | |
2479
139406606437
Use a MD5 hash of some frames to write the segment uid
conrad
parents:
2478
diff
changeset
|
863 |
2515 | 864 // write the md5sum of some frames as the segment UID |
865 if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) { | |
866 uint8_t segment_uid[16]; | |
867 av_md5_final(mkv->md5_ctx, segment_uid); | |
868 url_fseek(pb, mkv->segment_uid, SEEK_SET); | |
869 put_ebml_binary(pb, MATROSKA_ID_SEGMENTUID, segment_uid, 16); | |
870 } | |
871 url_fseek(pb, currentpos, SEEK_SET); | |
2514 | 872 } |
2443 | 873 |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
874 end_ebml_master(pb, mkv->segment); |
2479
139406606437
Use a MD5 hash of some frames to write the segment uid
conrad
parents:
2478
diff
changeset
|
875 av_free(mkv->md5_ctx); |
4239
5d0ac4d87ba1
Flush the buffer after writing the header and when done with writing the files
conrad
parents:
4223
diff
changeset
|
876 put_flush_packet(pb); |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
877 return 0; |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
878 } |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
879 |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
880 AVOutputFormat matroska_muxer = { |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
881 "matroska", |
3424
7a0230981402
Make long_names in lavf/lavdev optional depending on CONFIG_SMALL.
diego
parents:
3286
diff
changeset
|
882 NULL_IF_CONFIG_SMALL("Matroska file format"), |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
883 "video/x-matroska", |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
884 "mkv", |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
885 sizeof(MatroskaMuxContext), |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
886 CODEC_ID_MP2, |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
887 CODEC_ID_MPEG4, |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
888 mkv_write_header, |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
889 mkv_write_packet, |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
890 mkv_write_trailer, |
4567
963e3b76c7a6
Add AVFMT_VARIABLE_FPS to specify which muxers do not need duplicated frames.
michael
parents:
4498
diff
changeset
|
891 .flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS, |
5058
33a244b7ca65
Add ff_ prefixes to exported symbols in libavformat/riff.h.
diego
parents:
4581
diff
changeset
|
892 .codec_tag = (const AVCodecTag* const []){ff_codec_bmp_tags, ff_codec_wav_tags, 0}, |
2486 | 893 .subtitle_codec = CODEC_ID_TEXT, |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
894 }; |
2475 | 895 |
896 AVOutputFormat matroska_audio_muxer = { | |
897 "matroska", | |
3424
7a0230981402
Make long_names in lavf/lavdev optional depending on CONFIG_SMALL.
diego
parents:
3286
diff
changeset
|
898 NULL_IF_CONFIG_SMALL("Matroska file format"), |
2475 | 899 "audio/x-matroska", |
900 "mka", | |
901 sizeof(MatroskaMuxContext), | |
902 CODEC_ID_MP2, | |
903 CODEC_ID_NONE, | |
904 mkv_write_header, | |
905 mkv_write_packet, | |
906 mkv_write_trailer, | |
4002 | 907 .flags = AVFMT_GLOBALHEADER, |
5058
33a244b7ca65
Add ff_ prefixes to exported symbols in libavformat/riff.h.
diego
parents:
4581
diff
changeset
|
908 .codec_tag = (const AVCodecTag* const []){ff_codec_wav_tags, 0}, |
2475 | 909 }; |