#include "matroska.h"
#include "riff.h"
#include "subtitles.h"
+#include "vorbiscomment.h"
#include "wv.h"
#include "libavutil/avstring.h"
+#include "libavutil/channel_layout.h"
#include "libavutil/dict.h"
#include "libavutil/intfloat.h"
#include "libavutil/intreadwrite.h"
return 0;
}
-static int64_t mkv_write_cues(AVIOContext *pb, mkv_cues *cues, mkv_track *tracks, int num_tracks)
+static int64_t mkv_write_cues(AVFormatContext *s, mkv_cues *cues, mkv_track *tracks, int num_tracks)
{
+ AVIOContext *pb = s->pb;
ebml_master cues_element;
int64_t currentpos;
int i, j;
for (j = 0; j < cues->num_entries - i && entry[j].pts == pts; j++) {
int tracknum = entry[j].stream_idx;
av_assert0(tracknum>=0 && tracknum<num_tracks);
- if (tracks[tracknum].has_cue)
+ if (tracks[tracknum].has_cue && s->streams[tracknum]->codec->codec_type != AVMEDIA_TYPE_SUBTITLE)
continue;
tracks[tracknum].has_cue = 1;
track_positions = start_ebml_master(pb, MATROSKA_ID_CUETRACKPOSITION, MAX_CUETRACKPOS_SIZE);
return 0;
}
+static int put_flac_codecpriv(AVFormatContext *s,
+ AVIOContext *pb, AVCodecContext *codec)
+{
+ int write_comment = (codec->channel_layout &&
+ !(codec->channel_layout & ~0x3ffffULL) &&
+ !ff_flac_is_native_layout(codec->channel_layout));
+ int ret = ff_flac_write_header(pb, codec, !write_comment);
+
+ if (ret < 0)
+ return ret;
+
+ if (write_comment) {
+ const char *vendor = (s->flags & AVFMT_FLAG_BITEXACT) ?
+ "Lavf" : LIBAVFORMAT_IDENT;
+ AVDictionary *dict = NULL;
+ uint8_t buf[32], *data, *p;
+ int len;
+
+ snprintf(buf, sizeof(buf), "0x%"PRIx64, codec->channel_layout);
+ av_dict_set(&dict, "WAVEFORMATEXTENSIBLE_CHANNEL_MASK", buf, 0);
+
+ len = ff_vorbiscomment_length(dict, vendor);
+ data = av_malloc(len + 4);
+ if (!data) {
+ av_dict_free(&dict);
+ return AVERROR(ENOMEM);
+ }
+
+ data[0] = 0x84;
+ AV_WB24(data + 1, len);
+
+ p = data + 4;
+ ff_vorbiscomment_write(&p, &dict, vendor);
+
+ avio_write(pb, data, len + 4);
+
+ av_freep(&data);
+ av_dict_free(&dict);
+ }
+
+ return 0;
+}
+
static void get_aac_sample_rates(AVFormatContext *s, AVCodecContext *codec, int *sample_rate, int *output_sample_rate)
{
MPEG4AudioConfig mp4ac;
if (codec->codec_id == AV_CODEC_ID_VORBIS || codec->codec_id == AV_CODEC_ID_THEORA)
ret = put_xiph_codecpriv(s, dyn_cp, codec);
else if (codec->codec_id == AV_CODEC_ID_FLAC)
- ret = ff_flac_write_header(dyn_cp, codec, 1);
+ ret = put_flac_codecpriv(s, dyn_cp, codec);
else if (codec->codec_id == AV_CODEC_ID_WAVPACK)
ret = put_wv_codecpriv(dyn_cp, codec);
else if (codec->codec_id == AV_CODEC_ID_H264)
int display_height_div = 1;
AVDictionaryEntry *tag;
+ // ms precision is the de-facto standard timescale for mkv files
+ avpriv_set_pts_info(st, 64, 1, 1000);
+
if (codec->codec_type == AVMEDIA_TYPE_ATTACHMENT) {
mkv->have_attachments = 1;
continue;
if (mkv->mode == MODE_WEBM && !(codec->codec_id == AV_CODEC_ID_VP8 ||
codec->codec_id == AV_CODEC_ID_VP9 ||
- ((codec->codec_id == AV_CODEC_ID_OPUS)&&(codec->strict_std_compliance <= FF_COMPLIANCE_EXPERIMENTAL)) ||
+ codec->codec_id == AV_CODEC_ID_OPUS ||
codec->codec_id == AV_CODEC_ID_VORBIS ||
codec->codec_id == AV_CODEC_ID_WEBVTT)) {
av_log(s, AV_LOG_ERROR,
- "Only VP8,VP9 video and Vorbis,Opus(experimental, use -strict -2) audio and WebVTT subtitles are supported for WebM.\n");
+ "Only VP8 or VP9 video and Vorbis or Opus audio and WebVTT subtitles are supported for WebM.\n");
return AVERROR(EINVAL);
}
switch (codec->codec_type) {
case AVMEDIA_TYPE_VIDEO:
put_ebml_uint(pb, MATROSKA_ID_TRACKTYPE, MATROSKA_TRACK_TYPE_VIDEO);
- if(st->avg_frame_rate.num && st->avg_frame_rate.den && 1.0/av_q2d(st->avg_frame_rate) > av_q2d(codec->time_base))
- put_ebml_uint(pb, MATROSKA_ID_TRACKDEFAULTDURATION, 1E9/av_q2d(st->avg_frame_rate));
+
+ if( st->avg_frame_rate.num > 0 && st->avg_frame_rate.den > 0
+ && 1.0/av_q2d(st->avg_frame_rate) > av_q2d(codec->time_base))
+ put_ebml_uint(pb, MATROSKA_ID_TRACKDEFAULTDURATION, 1E9 / av_q2d(st->avg_frame_rate));
else
put_ebml_uint(pb, MATROSKA_ID_TRACKDEFAULTDURATION, av_q2d(codec->time_base)*1E9);
}
end_ebml_master(pb, track);
-
- // ms precision is the de-facto standard timescale for mkv files
- avpriv_set_pts_info(st, 64, 1, 1000);
}
end_ebml_master(pb, tracks);
return 0;
}
#if FF_API_ASS_SSA
-static int mkv_write_ass_blocks(AVFormatContext *s, AVIOContext *pb, AVPacket *pkt)
+/* Writes the contents of pkt to a block, using the data starting at *datap.
+ * If pkt corresponds to more than one block, this writes the contents of the first block
+ * (starting from *datap) and updates *datap so it points to the beginning of the data
+ * corresponding to the next block.
+ */
+static int mkv_write_ass_block(AVFormatContext *s, AVIOContext *pb, AVPacket *pkt, uint8_t **datap)
{
MatroskaMuxContext *mkv = s->priv_data;
- int i, layer = 0, max_duration = 0, size, line_size, data_size = pkt->size;
- uint8_t *start, *end, *data = pkt->data;
+ int i, layer = 0, size, line_size, data_size = pkt->size - (*datap - pkt->data);
+ uint8_t *start, *end, *data = *datap;
ebml_master blockgroup;
char buffer[2048];
- while (data_size) {
int duration = ass_get_duration(data);
- max_duration = FFMAX(duration, max_duration);
end = memchr(data, '\n', data_size);
size = line_size = end ? end-data+1 : data_size;
size -= end ? (end[-1]=='\r')+1 : 0;
start = data;
for (i=0; i<3; i++, start++)
if (!(start = memchr(start, ',', size-(start-data))))
- return max_duration;
+ return duration;
size -= start - data;
sscanf(data, "Dialogue: %d,", &layer);
i = snprintf(buffer, sizeof(buffer), "%"PRId64",%d,",
put_ebml_uint(pb, MATROSKA_ID_BLOCKDURATION, duration);
end_ebml_master(pb, blockgroup);
- data += line_size;
- data_size -= line_size;
- }
+ *datap += line_size;
- return max_duration;
+ return duration;
}
#endif
int ret;
int64_t ts = mkv->tracks[pkt->stream_index].write_dts ? pkt->dts : pkt->pts;
int64_t relative_packet_pos;
+ uint8_t *data_offset = pkt->data;
+ int dash_tracknum = mkv->is_dash ? mkv->dash_track_number : pkt->stream_index + 1;
if (ts == AV_NOPTS_VALUE) {
av_log(s, AV_LOG_ERROR, "Can't write packet with unknown timestamp\n");
if (codec->codec_type != AVMEDIA_TYPE_SUBTITLE) {
mkv_write_block(s, pb, MATROSKA_ID_SIMPLEBLOCK, pkt, keyframe << 7);
+ if (codec->codec_type == AVMEDIA_TYPE_VIDEO && keyframe) {
+ ret = mkv_add_cuepoint(mkv->cues, pkt->stream_index, dash_tracknum, ts, mkv->cluster_pos, relative_packet_pos, -1);
+ if (ret < 0) return ret;
+ }
#if FF_API_ASS_SSA
} else if (codec->codec_id == AV_CODEC_ID_SSA) {
- duration = mkv_write_ass_blocks(s, pb, pkt);
+ while (data_offset < pkt->data + pkt->size) {
+ duration = mkv_write_ass_block(s, pb, pkt, &data_offset);
+ ret = mkv_add_cuepoint(mkv->cues, pkt->stream_index, dash_tracknum, ts, mkv->cluster_pos, relative_packet_pos, duration);
+ if (ret < 0) return ret;
+ relative_packet_pos = avio_tell(s->pb) - mkv->cluster.pos;
+ }
#endif
- } else if (codec->codec_id == AV_CODEC_ID_SRT) {
+ } else {
+ if (codec->codec_id == AV_CODEC_ID_SRT) {
duration = mkv_write_srt_blocks(s, pb, pkt);
} else if (codec->codec_id == AV_CODEC_ID_WEBVTT) {
duration = mkv_write_vtt_blocks(s, pb, pkt);
end_ebml_master(pb, blockgroup);
}
- if ((codec->codec_type == AVMEDIA_TYPE_VIDEO && keyframe) ||
- codec->codec_type == AVMEDIA_TYPE_SUBTITLE ||
- add_cue) {
- ret = mkv_add_cuepoint(mkv->cues,
- pkt->stream_index,
- mkv->is_dash ? mkv->dash_track_number : pkt->stream_index + 1,
- ts, mkv->cluster_pos, relative_packet_pos,
- codec->codec_type == AVMEDIA_TYPE_SUBTITLE ? duration : -1);
- if (ret < 0) return ret;
+ ret = mkv_add_cuepoint(mkv->cues, pkt->stream_index, dash_tracknum, ts, mkv->cluster_pos, relative_packet_pos, duration);
+ if (ret < 0) return ret;
}
mkv->duration = FFMAX(mkv->duration, ts + duration);
currentpos = avio_tell(pb);
avio_seek(pb, mkv->cues_pos, SEEK_SET);
- cuespos = mkv_write_cues(pb, mkv->cues, mkv->tracks, s->nb_streams);
+ cuespos = mkv_write_cues(s, mkv->cues, mkv->tracks, s->nb_streams);
cues_end = avio_tell(pb);
if (cues_end > cuespos + mkv->reserve_cues_space) {
av_log(s, AV_LOG_ERROR, "Insufficient space reserved for cues: %d "
avio_seek(pb, currentpos, SEEK_SET);
} else {
- cuespos = mkv_write_cues(pb, mkv->cues, mkv->tracks, s->nb_streams);
+ cuespos = mkv_write_cues(s, mkv->cues, mkv->tracks, s->nb_streams);
}
ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_CUES, cuespos);
projects / ffmpeg / blobdiff