Mercurial > libavformat.hg
annotate matroskaenc.c @ 3754:8d267b43eaba libavformat
Move malloc() down until after all initializations, so that the resource is
only allocated if initialization worked. This means that on failure, we
don't have to deallocate it.
author | rbultje |
---|---|
date | Sat, 23 Aug 2008 18:46:30 +0000 |
parents | e8f67b6063c3 |
children | 27537074f2a9 |
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" |
3286 | 27 #include "libavutil/md5.h" |
28 #include "libavcodec/xiph.h" | |
3201 | 29 #include "libavcodec/mpeg4audio.h" |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
30 |
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
|
31 typedef struct 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
|
32 offset_t pos; ///< absolute offset in the file where the master's elements start |
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 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
|
34 } 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
|
35 |
2447 | 36 typedef struct mkv_seekhead_entry { |
37 unsigned int elementid; | |
38 uint64_t segmentpos; | |
39 } mkv_seekhead_entry; | |
40 | |
41 typedef struct mkv_seekhead { | |
42 offset_t filepos; | |
2450 | 43 offset_t segment_offset; ///< the file offset to the beginning of the segment |
44 int reserved_size; ///< -1 if appending to file | |
2447 | 45 int max_entries; |
46 mkv_seekhead_entry *entries; | |
47 int num_entries; | |
48 } mkv_seekhead; | |
49 | |
2451 | 50 typedef struct { |
51 uint64_t pts; | |
52 int tracknum; | |
53 offset_t cluster_pos; ///< file offset of the cluster containing the block | |
54 } mkv_cuepoint; | |
55 | |
56 typedef struct { | |
57 offset_t segment_offset; | |
58 mkv_cuepoint *entries; | |
59 int num_entries; | |
60 } mkv_cues; | |
61 | |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
62 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
|
63 ebml_master segment; |
2448 | 64 offset_t segment_offset; |
2479
139406606437
Use a MD5 hash of some frames to write the segment uid
conrad
parents:
2478
diff
changeset
|
65 offset_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
|
66 ebml_master cluster; |
2451 | 67 offset_t cluster_pos; ///< file offset of the current cluster |
2448 | 68 uint64_t cluster_pts; |
69 offset_t duration_offset; | |
70 uint64_t duration; | |
2447 | 71 mkv_seekhead *main_seekhead; |
72 mkv_seekhead *cluster_seekhead; | |
2451 | 73 mkv_cues *cues; |
2479
139406606437
Use a MD5 hash of some frames to write the segment uid
conrad
parents:
2478
diff
changeset
|
74 |
139406606437
Use a MD5 hash of some frames to write the segment uid
conrad
parents:
2478
diff
changeset
|
75 struct AVMD5 *md5_ctx; |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
76 } MatroskaMuxContext; |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
77 |
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
|
78 |
2506 | 79 /** 2 bytes * 3 for EBML IDs, 3 1-byte EBML lengths, 8 bytes for 64 bit |
80 * 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
|
81 #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
|
82 |
2506 | 83 /** per-cuepoint-track - 3 1-byte EBML IDs, 3 1-byte EBML sizes, 2 |
84 * 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
|
85 #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
|
86 |
2506 | 87 /** 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
|
88 #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
|
89 |
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 |
2481 | 91 static int ebml_id_size(unsigned int id) |
92 { | |
93 return (av_log2(id+1)-1)/7+1; | |
94 } | |
95 | |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
96 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
|
97 { |
2482 | 98 int i = ebml_id_size(id); |
99 while (i--) | |
100 put_byte(pb, id >> (i*8)); | |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
101 } |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
102 |
2480 | 103 /** |
2530 | 104 * Write an EBML size meaning "unknown size". |
2480 | 105 * |
2530 | 106 * @param bytes The number of bytes the size should occupy (maximum: 8). |
2480 | 107 */ |
108 static void put_ebml_size_unknown(ByteIOContext *pb, int bytes) | |
109 { | |
2497 | 110 assert(bytes <= 8); |
2496 | 111 put_byte(pb, 0x1ff >> bytes); |
112 while (--bytes) | |
113 put_byte(pb, 0xff); | |
2480 | 114 } |
115 | |
2484
60428e4e5242
Move calculating the bytes needed to represent a size in EBML to its own function
conrad
parents:
2483
diff
changeset
|
116 /** |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
117 * 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
|
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 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
|
120 { |
60428e4e5242
Move calculating the bytes needed to represent a size in EBML to its own function
conrad
parents:
2483
diff
changeset
|
121 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
|
122 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
|
123 return bytes; |
60428e4e5242
Move calculating the bytes needed to represent a size in EBML to its own function
conrad
parents:
2483
diff
changeset
|
124 } |
60428e4e5242
Move calculating the bytes needed to represent a size in EBML to its own function
conrad
parents:
2483
diff
changeset
|
125 |
2487
9a9c45b95c6f
Modify put_ebml_size() so that the bytes parameter is exact rather than minimum
conrad
parents:
2486
diff
changeset
|
126 /** |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
127 * 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
|
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 * @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
|
130 * 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
|
131 */ |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
132 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
|
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 int i, needed_bytes = ebml_num_size(num); |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
135 |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
136 // 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
|
137 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
|
138 |
2487
9a9c45b95c6f
Modify put_ebml_size() so that the bytes parameter is exact rather than minimum
conrad
parents:
2486
diff
changeset
|
139 if (bytes == 0) |
9a9c45b95c6f
Modify put_ebml_size() so that the bytes parameter is exact rather than minimum
conrad
parents:
2486
diff
changeset
|
140 // 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
|
141 bytes = needed_bytes; |
2498 | 142 // the bytes needed to write the given size would exceed the bytes |
143 // that we need to use, so write unknown size. This shouldn't happen. | |
2497 | 144 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
|
145 |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
146 num |= 1ULL << bytes*7; |
2485 | 147 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
|
148 put_byte(pb, num >> i*8); |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
149 } |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
150 |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
151 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
|
152 { |
2483 | 153 int i, bytes = 1; |
3097 | 154 uint64_t tmp = val; |
155 while (tmp>>=8) bytes++; | |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
156 |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
157 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
|
158 put_ebml_num(pb, bytes, 0); |
2483 | 159 for (i = bytes - 1; i >= 0; i--) |
160 put_byte(pb, val >> i*8); | |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
161 } |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
162 |
2430 | 163 static void put_ebml_float(ByteIOContext *pb, unsigned int elementid, double val) |
164 { | |
165 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
|
166 put_ebml_num(pb, 8, 0); |
2430 | 167 put_be64(pb, av_dbl2int(val)); |
168 } | |
169 | |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
170 static void put_ebml_binary(ByteIOContext *pb, unsigned int elementid, |
2429 | 171 const uint8_t *buf, int size) |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
172 { |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
173 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
|
174 put_ebml_num(pb, size, 0); |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
175 put_buffer(pb, buf, size); |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
176 } |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
177 |
2429 | 178 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
|
179 { |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
180 put_ebml_binary(pb, elementid, str, strlen(str)); |
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 |
2477 | 183 /** |
2494 | 184 * Writes a void element of a given size. Useful for reserving space in |
185 * the file to be written to later. | |
2477 | 186 * |
2491 | 187 * @param size The number of bytes to reserve, which must be at least 2. |
2477 | 188 */ |
2442 | 189 static void put_ebml_void(ByteIOContext *pb, uint64_t size) |
190 { | |
191 offset_t currentpos = url_ftell(pb); | |
192 | |
2497 | 193 assert(size >= 2); |
2442 | 194 |
195 put_ebml_id(pb, EBML_ID_VOID); | |
2494 | 196 // we need to subtract the length needed to store the size from the |
197 // size we need to reserve so 2 cases, we use 8 bytes to store the | |
198 // size if possible, 1 byte otherwise | |
2442 | 199 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
|
200 put_ebml_num(pb, size-1, 0); |
2442 | 201 else |
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-9, 8); |
2928
bdc992cb8e46
Write 0 instead of seeking forward (and leaving bytes uninitalized),
michael
parents:
2927
diff
changeset
|
203 while(url_ftell(pb) < currentpos + size) |
bdc992cb8e46
Write 0 instead of seeking forward (and leaving bytes uninitalized),
michael
parents:
2927
diff
changeset
|
204 put_byte(pb, 0); |
2442 | 205 } |
206 | |
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
|
207 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
|
208 { |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
209 int bytes = expectedsize ? ebml_num_size(expectedsize) : 8; |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
210 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
|
211 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
|
212 return (ebml_master){ url_ftell(pb), bytes }; |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
213 } |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
214 |
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
|
215 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
|
216 { |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
217 offset_t pos = url_ftell(pb); |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
218 |
2514 | 219 // leave the unknown size for masters when streaming |
220 if (url_is_streamed(pb)) | |
221 return; | |
222 | |
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
|
223 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
|
224 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
|
225 url_fseek(pb, pos, SEEK_SET); |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
226 } |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
227 |
2469 | 228 static void put_xiph_size(ByteIOContext *pb, int size) |
229 { | |
230 int i; | |
231 for (i = 0; i < size / 255; i++) | |
232 put_byte(pb, 255); | |
233 put_byte(pb, size % 255); | |
234 } | |
235 | |
2477 | 236 /** |
2494 | 237 * Initialize a mkv_seekhead element to be ready to index level 1 Matroska |
238 * elements. If a maximum number of elements is specified, enough space | |
239 * will be reserved at the current file location to write a seek head of | |
240 * that size. | |
2477 | 241 * |
2494 | 242 * @param segment_offset The absolute offset to the position in the file |
2519 | 243 * where the segment begins. |
244 * @param numelements The maximum number of elements that will be indexed | |
2494 | 245 * by this seek head, 0 if unlimited. |
2477 | 246 */ |
2447 | 247 static mkv_seekhead * mkv_start_seekhead(ByteIOContext *pb, offset_t segment_offset, int numelements) |
248 { | |
249 mkv_seekhead *new_seekhead = av_mallocz(sizeof(mkv_seekhead)); | |
250 if (new_seekhead == NULL) | |
251 return NULL; | |
252 | |
253 new_seekhead->segment_offset = segment_offset; | |
254 | |
255 if (numelements > 0) { | |
256 new_seekhead->filepos = url_ftell(pb); | |
2494 | 257 // 21 bytes max for a seek entry, 10 bytes max for the SeekHead ID |
258 // and size, and 3 bytes to guarantee that an EBML void element | |
259 // 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
|
260 new_seekhead->reserved_size = numelements * MAX_SEEKENTRY_SIZE + 13; |
2447 | 261 new_seekhead->max_entries = numelements; |
262 put_ebml_void(pb, new_seekhead->reserved_size); | |
263 } | |
264 return new_seekhead; | |
265 } | |
266 | |
267 static int mkv_add_seekhead_entry(mkv_seekhead *seekhead, unsigned int elementid, uint64_t filepos) | |
268 { | |
269 mkv_seekhead_entry *entries = seekhead->entries; | |
270 | |
271 // don't store more elements than we reserved space for | |
272 if (seekhead->max_entries > 0 && seekhead->max_entries <= seekhead->num_entries) | |
273 return -1; | |
274 | |
275 entries = av_realloc(entries, (seekhead->num_entries + 1) * sizeof(mkv_seekhead_entry)); | |
276 if (entries == NULL) | |
2499 | 277 return AVERROR(ENOMEM); |
2447 | 278 |
2507
048f4f45a84c
Use num_entries directly rather than mixing it with a local copy
conrad
parents:
2506
diff
changeset
|
279 entries[seekhead->num_entries ].elementid = elementid; |
048f4f45a84c
Use num_entries directly rather than mixing it with a local copy
conrad
parents:
2506
diff
changeset
|
280 entries[seekhead->num_entries++].segmentpos = filepos - seekhead->segment_offset; |
2447 | 281 |
282 seekhead->entries = entries; | |
283 return 0; | |
284 } | |
285 | |
2477 | 286 /** |
2494 | 287 * Write the seek head to the file and free it. If a maximum number of |
288 * elements was specified to mkv_start_seekhead(), the seek head will | |
289 * be written at the location reserved for it. Otherwise, it is written | |
290 * at the current location in the file. | |
2477 | 291 * |
2519 | 292 * @return The file offset where the seekhead was written. |
2477 | 293 */ |
2447 | 294 static offset_t mkv_write_seekhead(ByteIOContext *pb, mkv_seekhead *seekhead) |
295 { | |
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
|
296 ebml_master metaseek, seekentry; |
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
|
297 offset_t currentpos; |
2447 | 298 int i; |
299 | |
300 currentpos = url_ftell(pb); | |
301 | |
302 if (seekhead->reserved_size > 0) | |
303 url_fseek(pb, seekhead->filepos, SEEK_SET); | |
304 | |
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
|
305 metaseek = start_ebml_master(pb, MATROSKA_ID_SEEKHEAD, seekhead->reserved_size); |
2447 | 306 for (i = 0; i < seekhead->num_entries; i++) { |
307 mkv_seekhead_entry *entry = &seekhead->entries[i]; | |
308 | |
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
|
309 seekentry = start_ebml_master(pb, MATROSKA_ID_SEEKENTRY, MAX_SEEKENTRY_SIZE); |
2447 | 310 |
311 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
|
312 put_ebml_num(pb, ebml_id_size(entry->elementid), 0); |
2447 | 313 put_ebml_id(pb, entry->elementid); |
314 | |
315 put_ebml_uint(pb, MATROSKA_ID_SEEKPOSITION, entry->segmentpos); | |
316 end_ebml_master(pb, seekentry); | |
317 } | |
318 end_ebml_master(pb, metaseek); | |
319 | |
320 if (seekhead->reserved_size > 0) { | |
321 uint64_t remaining = seekhead->filepos + seekhead->reserved_size - url_ftell(pb); | |
322 put_ebml_void(pb, remaining); | |
323 url_fseek(pb, currentpos, SEEK_SET); | |
324 | |
325 currentpos = seekhead->filepos; | |
326 } | |
327 av_free(seekhead->entries); | |
328 av_free(seekhead); | |
329 | |
330 return currentpos; | |
331 } | |
332 | |
2451 | 333 static mkv_cues * mkv_start_cues(offset_t segment_offset) |
334 { | |
335 mkv_cues *cues = av_mallocz(sizeof(mkv_cues)); | |
336 if (cues == NULL) | |
337 return NULL; | |
338 | |
339 cues->segment_offset = segment_offset; | |
340 return cues; | |
341 } | |
342 | |
343 static int mkv_add_cuepoint(mkv_cues *cues, AVPacket *pkt, offset_t cluster_pos) | |
344 { | |
345 mkv_cuepoint *entries = cues->entries; | |
346 | |
347 entries = av_realloc(entries, (cues->num_entries + 1) * sizeof(mkv_cuepoint)); | |
348 if (entries == NULL) | |
2499 | 349 return AVERROR(ENOMEM); |
2451 | 350 |
2507
048f4f45a84c
Use num_entries directly rather than mixing it with a local copy
conrad
parents:
2506
diff
changeset
|
351 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
|
352 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
|
353 entries[cues->num_entries++].cluster_pos = cluster_pos - cues->segment_offset; |
2451 | 354 |
355 cues->entries = entries; | |
356 return 0; | |
357 } | |
358 | |
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
|
359 static offset_t mkv_write_cues(ByteIOContext *pb, mkv_cues *cues, int num_tracks) |
2451 | 360 { |
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
|
361 ebml_master cues_element; |
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
|
362 offset_t currentpos; |
2451 | 363 int i, j; |
364 | |
365 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
|
366 cues_element = start_ebml_master(pb, MATROSKA_ID_CUES, 0); |
2451 | 367 |
368 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
|
369 ebml_master cuepoint, track_positions; |
2451 | 370 mkv_cuepoint *entry = &cues->entries[i]; |
371 uint64_t pts = entry->pts; | |
372 | |
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
|
373 cuepoint = start_ebml_master(pb, MATROSKA_ID_POINTENTRY, MAX_CUEPOINT_SIZE(num_tracks)); |
2451 | 374 put_ebml_uint(pb, MATROSKA_ID_CUETIME, pts); |
375 | |
376 // put all the entries from different tracks that have the exact same | |
377 // timestamp into the same CuePoint | |
378 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
|
379 track_positions = start_ebml_master(pb, MATROSKA_ID_CUETRACKPOSITION, MAX_CUETRACKPOS_SIZE); |
2451 | 380 put_ebml_uint(pb, MATROSKA_ID_CUETRACK , entry[j].tracknum ); |
381 put_ebml_uint(pb, MATROSKA_ID_CUECLUSTERPOSITION, entry[j].cluster_pos); | |
382 end_ebml_master(pb, track_positions); | |
383 } | |
384 i += j - 1; | |
385 end_ebml_master(pb, cuepoint); | |
386 } | |
387 end_ebml_master(pb, cues_element); | |
388 | |
389 av_free(cues->entries); | |
390 av_free(cues); | |
391 return currentpos; | |
392 } | |
393 | |
2518 | 394 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
|
395 { |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
396 uint8_t *header_start[3]; |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
397 int header_len[3]; |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
398 int first_header_size; |
2469 | 399 int j; |
2444
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
400 |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
401 if (codec->codec_id == CODEC_ID_VORBIS) |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
402 first_header_size = 30; |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
403 else |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
404 first_header_size = 42; |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
405 |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
406 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
|
407 first_header_size, header_start, header_len) < 0) { |
2518 | 408 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
|
409 return -1; |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
410 } |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
411 |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
412 put_byte(pb, 2); // number packets - 1 |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
413 for (j = 0; j < 2; j++) { |
2469 | 414 put_xiph_size(pb, header_len[j]); |
2444
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
415 } |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
416 for (j = 0; j < 3; j++) |
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
417 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
|
418 |
b2f9523ee424
Make sure to return a value in functions that return a value
conrad
parents:
2445
diff
changeset
|
419 return 0; |
2444
d954330691c5
Move Xiph's CodecPrivate writing code to its own function
conrad
parents:
2443
diff
changeset
|
420 } |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
421 |
2470 | 422 #define FLAC_STREAMINFO_SIZE 34 |
423 | |
2518 | 424 static int put_flac_codecpriv(AVFormatContext *s, ByteIOContext *pb, AVCodecContext *codec) |
2470 | 425 { |
426 // if the extradata_size is greater than FLAC_STREAMINFO_SIZE, | |
3692 | 427 // assume that it's in Matroska format already |
2470 | 428 if (codec->extradata_size < FLAC_STREAMINFO_SIZE) { |
2518 | 429 av_log(s, AV_LOG_ERROR, "Invalid FLAC extradata\n"); |
2470 | 430 return -1; |
431 } else if (codec->extradata_size == FLAC_STREAMINFO_SIZE) { | |
432 // only the streaminfo packet | |
3271 | 433 put_buffer(pb, "fLaC", 4); |
434 put_byte(pb, 0x80); | |
435 put_be24(pb, FLAC_STREAMINFO_SIZE); | |
436 } else if(memcmp("fLaC", codec->extradata, 4)) { | |
437 av_log(s, AV_LOG_ERROR, "Invalid FLAC extradata\n"); | |
438 return -1; | |
2470 | 439 } |
440 put_buffer(pb, codec->extradata, codec->extradata_size); | |
441 return 0; | |
442 } | |
443 | |
2518 | 444 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
|
445 { |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
446 int sri; |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
447 |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
448 if (codec->extradata_size < 2) { |
2519 | 449 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
|
450 return; |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
451 } |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
452 |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
453 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
|
454 if (sri > 12) { |
2518 | 455 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
|
456 return; |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
457 } |
3201 | 458 *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
|
459 |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
460 // 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
|
461 if (codec->extradata_size == 5) { |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
462 sri = (codec->extradata[4] >> 3) & 0xF; |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
463 if (sri > 12) { |
2518 | 464 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
|
465 return; |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
466 } |
3201 | 467 *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
|
468 } |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
469 } |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
470 |
3601 | 471 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
|
472 { |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
473 ByteIOContext *dyn_cp; |
2510
4ba8d5f648a4
Write codecprivate to a dynamic buffer so that seeking isn't required
conrad
parents:
2509
diff
changeset
|
474 uint8_t *codecpriv; |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
475 int ret, codecpriv_size; |
2510
4ba8d5f648a4
Write codecprivate to a dynamic buffer so that seeking isn't required
conrad
parents:
2509
diff
changeset
|
476 |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
477 ret = url_open_dyn_buf(&dyn_cp); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
478 if(ret < 0) |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
479 return ret; |
2509
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
480 |
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
481 if (native_id) { |
2513 | 482 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
|
483 ret = put_xiph_codecpriv(s, dyn_cp, codec); |
2513 | 484 else if (codec->codec_id == CODEC_ID_FLAC) |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
485 ret = put_flac_codecpriv(s, dyn_cp, codec); |
2923
0fde8da65761
Use the isom avcc formatting for h264 extradata in matroska.
aurel
parents:
2771
diff
changeset
|
486 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
|
487 ret = ff_isom_write_avcc(dyn_cp, codec->extradata, codec->extradata_size); |
2513 | 488 else if (codec->extradata_size) |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
489 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
|
490 } else if (codec->codec_type == CODEC_TYPE_VIDEO) { |
3601 | 491 if (qt_id) { |
492 if (!codec->codec_tag) | |
493 codec->codec_tag = codec_get_tag(codec_movvideo_tags, codec->codec_id); | |
494 if (codec->extradata_size) | |
495 put_buffer(dyn_cp, codec->extradata, codec->extradata_size); | |
496 } else { | |
2509
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
497 if (!codec->codec_tag) |
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
498 codec->codec_tag = codec_get_tag(codec_bmp_tags, codec->codec_id); |
2511
0ca390638aa5
Match the behaviour betwen the bmp and wav codec tag lookups
conrad
parents:
2510
diff
changeset
|
499 if (!codec->codec_tag) { |
2519 | 500 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
|
501 ret = -1; |
0ca390638aa5
Match the behaviour betwen the bmp and wav codec tag lookups
conrad
parents:
2510
diff
changeset
|
502 } |
2509
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
503 |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
504 put_bmp_header(dyn_cp, codec, codec_bmp_tags, 0); |
3601 | 505 } |
2509
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
506 |
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
507 } 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
|
508 if (!codec->codec_tag) |
2512 | 509 codec->codec_tag = codec_get_tag(codec_wav_tags, codec->codec_id); |
2509
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
510 if (!codec->codec_tag) { |
2519 | 511 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
|
512 ret = -1; |
2509
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
513 } |
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
514 |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
515 put_wav_header(dyn_cp, codec); |
2509
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
516 } |
2510
4ba8d5f648a4
Write codecprivate to a dynamic buffer so that seeking isn't required
conrad
parents:
2509
diff
changeset
|
517 |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
518 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
|
519 if (codecpriv_size) |
4ba8d5f648a4
Write codecprivate to a dynamic buffer so that seeking isn't required
conrad
parents:
2509
diff
changeset
|
520 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
|
521 av_free(codecpriv); |
4ba8d5f648a4
Write codecprivate to a dynamic buffer so that seeking isn't required
conrad
parents:
2509
diff
changeset
|
522 return ret; |
2509
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
523 } |
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
524 |
2445
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
525 static int mkv_write_tracks(AVFormatContext *s) |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
526 { |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
527 MatroskaMuxContext *mkv = s->priv_data; |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
528 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
|
529 ebml_master tracks; |
2501 | 530 int i, j, ret; |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
531 |
2501 | 532 ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_TRACKS, url_ftell(pb)); |
533 if (ret < 0) return ret; | |
2447 | 534 |
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
|
535 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
|
536 for (i = 0; i < s->nb_streams; i++) { |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
537 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
|
538 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
|
539 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
|
540 int native_id = 0; |
3601 | 541 int qt_id = 0; |
2454 | 542 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
|
543 int sample_rate = codec->sample_rate; |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
544 int output_sample_rate = 0; |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
545 |
2493
61bc7a789851
Use sample format for bit depth if av_get_bits_per_sample() doesn't give one
conrad
parents:
2492
diff
changeset
|
546 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
|
547 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
|
548 |
2458
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
549 if (codec->codec_id == CODEC_ID_AAC) |
2518 | 550 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
|
551 |
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
|
552 track = start_ebml_master(pb, MATROSKA_ID_TRACKENTRY, 0); |
2439 | 553 put_ebml_uint (pb, MATROSKA_ID_TRACKNUMBER , i + 1); |
554 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
|
555 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
|
556 |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
557 if (st->language[0]) |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
558 put_ebml_string(pb, MATROSKA_ID_TRACKLANGUAGE, st->language); |
2476
4121545128f3
Set the language to undefined if no language specified
conrad
parents:
2475
diff
changeset
|
559 else |
4121545128f3
Set the language to undefined if no language specified
conrad
parents:
2475
diff
changeset
|
560 put_ebml_string(pb, MATROSKA_ID_TRACKLANGUAGE, "und"); |
2432
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
561 |
3120
ea5623a8efde
Add 'disposition' bitfield to AVStream and use it for both muxing and demuxing
eugeni
parents:
3097
diff
changeset
|
562 put_ebml_uint(pb, MATROSKA_ID_TRACKFLAGDEFAULT, !!(st->disposition & AV_DISPOSITION_DEFAULT)); |
ea5623a8efde
Add 'disposition' bitfield to AVStream and use it for both muxing and demuxing
eugeni
parents:
3097
diff
changeset
|
563 |
2519 | 564 // look for a codec ID string specific to mkv to use, |
2494 | 565 // 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
|
566 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
|
567 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
|
568 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
|
569 native_id = 1; |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
570 break; |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
571 } |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
572 } |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
573 |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
574 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
|
575 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
|
576 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
|
577 |
3601 | 578 if (!native_id && |
579 codec_get_tag(codec_movvideo_tags, codec->codec_id) && | |
580 (!codec_get_tag(codec_bmp_tags, codec->codec_id) | |
581 || codec->codec_id == CODEC_ID_SVQ1 | |
582 || codec->codec_id == CODEC_ID_SVQ3 | |
583 || codec->codec_id == CODEC_ID_CINEPAK)) | |
584 qt_id = 1; | |
585 | |
586 if (qt_id) | |
587 put_ebml_string(pb, MATROSKA_ID_CODECID, "V_QUICKTIME"); | |
588 else if (!native_id) | |
2519 | 589 // 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
|
590 put_ebml_string(pb, MATROSKA_ID_CODECID, "V_MS/VFW/FOURCC"); |
2513 | 591 |
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
|
592 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
|
593 // XXX: interlace flag? |
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_VIDEOPIXELWIDTH , codec->width); |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
595 put_ebml_uint (pb, MATROSKA_ID_VIDEOPIXELHEIGHT, codec->height); |
2473 | 596 if (codec->sample_aspect_ratio.num) { |
2504 | 597 AVRational dar = av_mul_q(codec->sample_aspect_ratio, |
598 (AVRational){codec->width, codec->height}); | |
2492 | 599 put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH , dar.num); |
600 put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, dar.den); | |
2473 | 601 } |
2432
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
602 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
|
603 break; |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
604 |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
605 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
|
606 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
|
607 |
2513 | 608 if (!native_id) |
2452
1b6ea48f7f24
Write wav header if there is no native audio codec ID
conrad
parents:
2451
diff
changeset
|
609 // no mkv-specific ID, use ACM mode |
3687
494a55f131f3
matroska: expand useless define for MS compat codec id strings
aurel
parents:
3601
diff
changeset
|
610 put_ebml_string(pb, MATROSKA_ID_CODECID, "A_MS/ACM"); |
2513 | 611 |
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
|
612 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
|
613 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
|
614 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
|
615 if (output_sample_rate) |
7286ab3bf026
Determine the output sample rate for SBR AAC and write it
conrad
parents:
2457
diff
changeset
|
616 put_ebml_float(pb, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, output_sample_rate); |
2453 | 617 if (bit_depth) |
618 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
|
619 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
|
620 break; |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
621 |
2498 | 622 case CODEC_TYPE_SUBTITLE: |
623 put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, MATROSKA_TRACK_TYPE_SUBTITLE); | |
624 break; | |
2432
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
625 default: |
2503 | 626 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
|
627 break; |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
628 } |
3601 | 629 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
|
630 if (ret < 0) return ret; |
5abcad2566b3
Move writing codec private element to its own function
conrad
parents:
2508
diff
changeset
|
631 |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
632 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
|
633 |
68743e7fa627
First stab at writing the tracks element, still needs some additional cases for certain codecs
conrad
parents:
2431
diff
changeset
|
634 // 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
|
635 av_set_pts_info(st, 64, 1, 1000); |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
636 } |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
637 end_ebml_master(pb, tracks); |
2446
b2f9523ee424
Make sure to return a value in functions that return a value
conrad
parents:
2445
diff
changeset
|
638 return 0; |
2445
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
639 } |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
640 |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
641 static int mkv_write_header(AVFormatContext *s) |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
642 { |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
643 MatroskaMuxContext *mkv = s->priv_data; |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
644 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
|
645 ebml_master ebml_header, segment_info; |
2501 | 646 int ret; |
2445
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
647 |
2479
139406606437
Use a MD5 hash of some frames to write the segment uid
conrad
parents:
2478
diff
changeset
|
648 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
|
649 av_md5_init(mkv->md5_ctx); |
139406606437
Use a MD5 hash of some frames to write the segment uid
conrad
parents:
2478
diff
changeset
|
650 |
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
|
651 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
|
652 put_ebml_uint (pb, EBML_ID_EBMLVERSION , 1); |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
653 put_ebml_uint (pb, EBML_ID_EBMLREADVERSION , 1); |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
654 put_ebml_uint (pb, EBML_ID_EBMLMAXIDLENGTH , 4); |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
655 put_ebml_uint (pb, EBML_ID_EBMLMAXSIZELENGTH , 8); |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
656 put_ebml_string (pb, EBML_ID_DOCTYPE , "matroska"); |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
657 put_ebml_uint (pb, EBML_ID_DOCTYPEVERSION , 2); |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
658 put_ebml_uint (pb, EBML_ID_DOCTYPEREADVERSION , 2); |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
659 end_ebml_master(pb, ebml_header); |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
660 |
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
|
661 mkv->segment = start_ebml_master(pb, MATROSKA_ID_SEGMENT, 0); |
2447 | 662 mkv->segment_offset = url_ftell(pb); |
663 | |
2494 | 664 // we write 2 seek heads - one at the end of the file to point to each |
665 // cluster, and one at the beginning to point to all other level one | |
666 // elements (including the seek head at the end of the file), which | |
667 // isn't more than 10 elements if we only write one of each other | |
668 // currently defined level 1 element | |
2447 | 669 mkv->main_seekhead = mkv_start_seekhead(pb, mkv->segment_offset, 10); |
670 mkv->cluster_seekhead = mkv_start_seekhead(pb, mkv->segment_offset, 0); | |
2500 | 671 if (mkv->main_seekhead == NULL || mkv->cluster_seekhead == NULL) |
672 return AVERROR(ENOMEM); | |
2447 | 673 |
2501 | 674 ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_INFO, url_ftell(pb)); |
675 if (ret < 0) return ret; | |
2445
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
676 |
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
|
677 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
|
678 put_ebml_uint(pb, MATROSKA_ID_TIMECODESCALE, 1000000); |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
679 if (strlen(s->title)) |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
680 put_ebml_string(pb, MATROSKA_ID_TITLE, s->title); |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
681 if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) { |
2466 | 682 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
|
683 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
|
684 |
139406606437
Use a MD5 hash of some frames to write the segment uid
conrad
parents:
2478
diff
changeset
|
685 // 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
|
686 mkv->segment_uid = url_ftell(pb); |
139406606437
Use a MD5 hash of some frames to write the segment uid
conrad
parents:
2478
diff
changeset
|
687 put_ebml_void(pb, 19); |
2445
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
688 } |
2468 | 689 |
2445
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
690 // reserve space for the duration |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
691 mkv->duration = 0; |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
692 mkv->duration_offset = url_ftell(pb); |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
693 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
|
694 end_ebml_master(pb, segment_info); |
86466f60fc5d
Move writing the tracks element to its own function
conrad
parents:
2444
diff
changeset
|
695 |
2501 | 696 ret = mkv_write_tracks(s); |
697 if (ret < 0) return ret; | |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
698 |
2501 | 699 ret = mkv_add_seekhead_entry(mkv->cluster_seekhead, MATROSKA_ID_CLUSTER, url_ftell(pb)); |
700 if (ret < 0) return ret; | |
2447 | 701 |
2451 | 702 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
|
703 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
|
704 put_ebml_uint(pb, MATROSKA_ID_CLUSTERTIMECODE, 0); |
2437 | 705 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
|
706 |
2451 | 707 mkv->cues = mkv_start_cues(mkv->segment_offset); |
708 if (mkv->cues == NULL) | |
2499 | 709 return AVERROR(ENOMEM); |
2451 | 710 |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
711 return 0; |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
712 } |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
713 |
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
|
714 static int mkv_block_size(AVPacket *pkt) |
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
|
715 { |
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
|
716 int size = 4; // track num + timecode + flags |
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
|
717 return size + pkt->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
|
718 } |
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
|
719 |
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
|
720 static int mkv_blockgroup_size(AVPacket *pkt) |
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
|
721 { |
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
|
722 int size = mkv_block_size(pkt); |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
723 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
|
724 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
|
725 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
|
726 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
|
727 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
|
728 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
|
729 } |
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
|
730 |
2460 | 731 static void mkv_write_block(AVFormatContext *s, unsigned int blockid, AVPacket *pkt, int flags) |
732 { | |
733 MatroskaMuxContext *mkv = s->priv_data; | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
734 ByteIOContext *pb = s->pb; |
2460 | 735 |
2504 | 736 av_log(s, AV_LOG_DEBUG, "Writing block at offset %" PRIu64 ", size %d, " |
737 "pts %" PRId64 ", dts %" PRId64 ", duration %d, flags %d\n", | |
2474 | 738 url_ftell(pb), pkt->size, pkt->pts, pkt->dts, pkt->duration, flags); |
2460 | 739 put_ebml_id(pb, blockid); |
2517
ac3e650ec92c
Rename ebml size functions to indicate that they can be used for more kinds of numbers
conrad
parents:
2516
diff
changeset
|
740 put_ebml_num(pb, mkv_block_size(pkt), 0); |
2460 | 741 put_byte(pb, 0x80 | (pkt->stream_index + 1)); // this assumes stream_index is less than 126 |
742 put_be16(pb, pkt->pts - mkv->cluster_pts); | |
743 put_byte(pb, flags); | |
744 put_buffer(pb, pkt->data, pkt->size); | |
745 } | |
746 | |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
747 static int mkv_write_packet(AVFormatContext *s, AVPacket *pkt) |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
748 { |
2437 | 749 MatroskaMuxContext *mkv = s->priv_data; |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
750 ByteIOContext *pb = s->pb; |
2463 | 751 AVCodecContext *codec = s->streams[pkt->stream_index]->codec; |
2455 | 752 int keyframe = !!(pkt->flags & PKT_FLAG_KEY); |
2501 | 753 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
|
754 |
2437 | 755 // start a new cluster every 5 MB or 5 sec |
2488 | 756 if (url_ftell(pb) > mkv->cluster_pos + 5*1024*1024 || pkt->pts > mkv->cluster_pts + 5000) { |
2504 | 757 av_log(s, AV_LOG_DEBUG, "Starting new cluster at offset %" PRIu64 |
758 " bytes, pts %" PRIu64 "\n", url_ftell(pb), pkt->pts); | |
2437 | 759 end_ebml_master(pb, mkv->cluster); |
2447 | 760 |
2501 | 761 ret = mkv_add_seekhead_entry(mkv->cluster_seekhead, MATROSKA_ID_CLUSTER, url_ftell(pb)); |
762 if (ret < 0) return ret; | |
2447 | 763 |
2451 | 764 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
|
765 mkv->cluster = start_ebml_master(pb, MATROSKA_ID_CLUSTER, 0); |
2437 | 766 put_ebml_uint(pb, MATROSKA_ID_CLUSTERTIMECODE, pkt->pts); |
767 mkv->cluster_pts = pkt->pts; | |
2479
139406606437
Use a MD5 hash of some frames to write the segment uid
conrad
parents:
2478
diff
changeset
|
768 av_md5_update(mkv->md5_ctx, pkt->data, FFMIN(200, pkt->size)); |
2437 | 769 } |
770 | |
2926
a6730b458d6c
Matroska muxer needs to format all NAL units, not only extradata.
aurel
parents:
2923
diff
changeset
|
771 if (codec->codec_id == CODEC_ID_H264 && |
a6730b458d6c
Matroska muxer needs to format all NAL units, not only extradata.
aurel
parents:
2923
diff
changeset
|
772 codec->extradata_size > 0 && AV_RB32(codec->extradata) == 0x00000001) { |
a6730b458d6c
Matroska muxer needs to format all NAL units, not only extradata.
aurel
parents:
2923
diff
changeset
|
773 /* from x264 or from bytestream h264 */ |
a6730b458d6c
Matroska muxer needs to format all NAL units, not only extradata.
aurel
parents:
2923
diff
changeset
|
774 /* nal reformating needed */ |
2927
b75a49790f31
add a ff_ prefix to newly exported functions from avc.c
aurel
parents:
2926
diff
changeset
|
775 int ret = ff_avc_parse_nal_units(pkt->data, &pkt->data, &pkt->size); |
2926
a6730b458d6c
Matroska muxer needs to format all NAL units, not only extradata.
aurel
parents:
2923
diff
changeset
|
776 if (ret < 0) |
a6730b458d6c
Matroska muxer needs to format all NAL units, not only extradata.
aurel
parents:
2923
diff
changeset
|
777 return ret; |
a6730b458d6c
Matroska muxer needs to format all NAL units, not only extradata.
aurel
parents:
2923
diff
changeset
|
778 assert(pkt->size); |
a6730b458d6c
Matroska muxer needs to format all NAL units, not only extradata.
aurel
parents:
2923
diff
changeset
|
779 } |
a6730b458d6c
Matroska muxer needs to format all NAL units, not only extradata.
aurel
parents:
2923
diff
changeset
|
780 |
2463 | 781 if (codec->codec_type != CODEC_TYPE_SUBTITLE) { |
2462 | 782 mkv_write_block(s, MATROSKA_ID_SIMPLEBLOCK, pkt, keyframe << 7); |
2461 | 783 } else { |
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
|
784 ebml_master blockgroup = start_ebml_master(pb, MATROSKA_ID_BLOCKGROUP, mkv_blockgroup_size(pkt)); |
2461 | 785 mkv_write_block(s, MATROSKA_ID_BLOCK, pkt, 0); |
786 put_ebml_uint(pb, MATROSKA_ID_DURATION, pkt->duration); | |
787 end_ebml_master(pb, blockgroup); | |
788 } | |
2443 | 789 |
2463 | 790 if (codec->codec_type == CODEC_TYPE_VIDEO && keyframe) { |
2501 | 791 ret = mkv_add_cuepoint(mkv->cues, pkt, mkv->cluster_pos); |
792 if (ret < 0) return ret; | |
2451 | 793 } |
794 | |
2505
81b1f6c373b4
Make sure that the calculated duration doesn't decrease
conrad
parents:
2504
diff
changeset
|
795 mkv->duration = FFMAX(mkv->duration, pkt->pts + pkt->duration); |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
796 return 0; |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
797 } |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
798 |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
799 static int mkv_write_trailer(AVFormatContext *s) |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
800 { |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
801 MatroskaMuxContext *mkv = s->priv_data; |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2530
diff
changeset
|
802 ByteIOContext *pb = s->pb; |
2451 | 803 offset_t currentpos, second_seekhead, cuespos; |
2502 | 804 int ret; |
2443 | 805 |
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
|
806 end_ebml_master(pb, mkv->cluster); |
2443 | 807 |
2514 | 808 if (!url_is_streamed(pb)) { |
2515 | 809 cuespos = mkv_write_cues(pb, mkv->cues, s->nb_streams); |
810 second_seekhead = mkv_write_seekhead(pb, mkv->cluster_seekhead); | |
2451 | 811 |
2515 | 812 ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_CUES , cuespos); |
813 if (ret < 0) return ret; | |
814 ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_SEEKHEAD, second_seekhead); | |
815 if (ret < 0) return ret; | |
816 mkv_write_seekhead(pb, mkv->main_seekhead); | |
2447 | 817 |
2515 | 818 // update the duration |
819 av_log(s, AV_LOG_DEBUG, "end duration = %" PRIu64 "\n", mkv->duration); | |
820 currentpos = url_ftell(pb); | |
821 url_fseek(pb, mkv->duration_offset, SEEK_SET); | |
822 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
|
823 |
2515 | 824 // write the md5sum of some frames as the segment UID |
825 if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) { | |
826 uint8_t segment_uid[16]; | |
827 av_md5_final(mkv->md5_ctx, segment_uid); | |
828 url_fseek(pb, mkv->segment_uid, SEEK_SET); | |
829 put_ebml_binary(pb, MATROSKA_ID_SEGMENTUID, segment_uid, 16); | |
830 } | |
831 url_fseek(pb, currentpos, SEEK_SET); | |
2514 | 832 } |
2443 | 833 |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
834 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
|
835 av_free(mkv->md5_ctx); |
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 AVOutputFormat matroska_muxer = { |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
840 "matroska", |
3424
7a0230981402
Make long_names in lavf/lavdev optional depending on CONFIG_SMALL.
diego
parents:
3286
diff
changeset
|
841 NULL_IF_CONFIG_SMALL("Matroska file format"), |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
842 "video/x-matroska", |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
843 "mkv", |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
844 sizeof(MatroskaMuxContext), |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
845 CODEC_ID_MP2, |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
846 CODEC_ID_MPEG4, |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
847 mkv_write_header, |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
848 mkv_write_packet, |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
849 mkv_write_trailer, |
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
850 .codec_tag = (const AVCodecTag*[]){codec_bmp_tags, codec_wav_tags, 0}, |
2486 | 851 .subtitle_codec = CODEC_ID_TEXT, |
2425
8c51e92edd7d
Beginning of mkv muxer, only EBML head is written correctly
conrad
parents:
diff
changeset
|
852 }; |
2475 | 853 |
854 AVOutputFormat matroska_audio_muxer = { | |
855 "matroska", | |
3424
7a0230981402
Make long_names in lavf/lavdev optional depending on CONFIG_SMALL.
diego
parents:
3286
diff
changeset
|
856 NULL_IF_CONFIG_SMALL("Matroska file format"), |
2475 | 857 "audio/x-matroska", |
858 "mka", | |
859 sizeof(MatroskaMuxContext), | |
860 CODEC_ID_MP2, | |
861 CODEC_ID_NONE, | |
862 mkv_write_header, | |
863 mkv_write_packet, | |
864 mkv_write_trailer, | |
865 .codec_tag = (const AVCodecTag*[]){codec_wav_tags, 0}, | |
866 }; |