Lines Matching refs:track
78 { "separate_moof", "Write separate moof/mdat atoms for each track", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_SEPARATE_MOOF}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
98 { "use_timed_meta_track", "Use timed meta data track for linking metadata to another track", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_TIMED_METADATA}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
117 { "use_stream_ids_as_track_ids", "use stream ids as track ids", offsetof(MOVMuxContext, use_stream_ids_as_track_ids), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
168 static int co64_required(const MOVTrack *track)
170 if (track->entry > 0 && track->cluster[track->entry - 1].pos + track->data_offset > UINT32_MAX)
178 * is encoded as sparse video track */
192 static int mov_write_stco_tag(AVIOContext *pb, MOVTrack *track)
195 int mode64 = co64_required(track); // use 32 bit size variant if possible
203 avio_wb32(pb, track->chunkCount); /* entry count */
204 for (i = 0; i < track->entry; i++) {
205 if (!track->cluster[i].chunkNum)
208 avio_wb64(pb, track->cluster[i].pos + track->data_offset);
210 avio_wb32(pb, track->cluster[i].pos + track->data_offset);
216 static int mov_write_stsz_tag(AVIOContext *pb, MOVTrack *track)
226 for (i = 0; i < track->entry; i++) {
227 tst = track->cluster[i].size / track->cluster[i].entries;
231 entries += track->cluster[i].entries;
233 if (equalChunks && track->entry) {
234 int sSize = track->entry ? track->cluster[0].size / track->cluster[0].entries : 0;
241 for (i = 0; i < track->entry; i++) {
242 for (j = 0; j < track->cluster[i].entries; j++) {
243 avio_wb32(pb, track->cluster[i].size /
244 track->cluster[i].entries);
252 static int mov_write_stsc_tag(AVIOContext *pb, MOVTrack *track)
262 avio_wb32(pb, track->chunkCount); // entry count
263 for (i = 0; i < track->entry; i++) {
264 if (oldval != track->cluster[i].samples_in_chunk && track->cluster[i].chunkNum) {
265 avio_wb32(pb, track->cluster[i].chunkNum); // first chunk
266 avio_wb32(pb, track->cluster[i].samples_in_chunk); // samples per chunk
268 oldval = track->cluster[i].samples_in_chunk;
281 static int mov_write_stss_tag(AVIOContext *pb, MOVTrack *track, uint32_t flag)
290 avio_wb32(pb, track->entry); // entry count
291 for (i = 0; i < track->entry; i++) {
292 if (track->cluster[i].flags & flag) {
305 static int mov_write_sdtp_tag(AVIOContext *pb, MOVTrack *track)
313 for (i = 0; i < track->entry; i++) {
316 if (track->cluster[i].flags & MOV_DISPOSABLE_SAMPLE) {
319 } else if (track->cluster[i].flags & MOV_DISPOSABLE_EXT_SAMPLE) {
323 if (track->cluster[i].flags & MOV_SYNC_SAMPLE) {
332 static int mov_write_amr_tag(AVIOContext *pb, MOVTrack *track)
335 if (track->mode == MODE_MOV) ffio_wfourcc(pb, "samr");
379 static int mov_write_ac3_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
381 struct eac3_info *info = track->eac3_priv;
425 static int handle_eac3(MOVMuxContext *mov, AVPacket *pkt, MOVTrack *track)
431 if (!track->eac3_priv) {
432 if (!(track->eac3_priv = av_mallocz(sizeof(*info))))
435 ((struct eac3_info *)track->eac3_priv)->ac3_bit_rate_code = -1;
437 info = track->eac3_priv;
447 if (!track->entry) {
502 if (track->par->codec_id == AV_CODEC_ID_AC3) {
505 // have been set to the track's informational structure.
584 static int mov_write_eac3_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
591 if (!track->eac3_priv) {
597 info = track->eac3_priv;
639 static int mov_write_extradata_tag(AVIOContext *pb, MOVTrack *track)
641 avio_write(pb, track->par->extradata, track->par->extradata_size);
642 return track->par->extradata_size;
670 static unsigned compute_avg_bitrate(MOVTrack *track)
674 if (!track->track_duration)
676 for (i = 0; i < track->entry; i++)
677 size += track->cluster[i].size;
678 return size * 8 * track->timescale / track->track_duration;
687 static struct mpeg4_bit_rate_values calculate_mpeg4_bit_rates(MOVTrack *track)
689 AVCPBProperties *props = track->st ?
690 (AVCPBProperties*)av_stream_get_side_data(track->st,
696 bit_rates.avg_bit_rate = compute_avg_bitrate(track);
708 } else if (track->par->bit_rate) {
709 bit_rates.avg_bit_rate = track->par->bit_rate;
716 bit_rates.max_bit_rate = FFMAX(track->par->bit_rate,
729 static int mov_write_esds_tag(AVIOContext *pb, MOVTrack *track) // Basic
731 struct mpeg4_bit_rate_values bit_rates = calculate_mpeg4_bit_rates(track);
733 int decoder_specific_info_len = track->vos_len ? 5 + track->vos_len : 0;
741 avio_wb16(pb, track->track_id);
748 if ((track->par->codec_id == AV_CODEC_ID_MP2 ||
749 track->par->codec_id == AV_CODEC_ID_MP3) &&
750 track->par->sample_rate > 24000)
753 avio_w8(pb, ff_codec_get_tag(ff_mp4_obj_type, track->par->codec_id));
757 if (track->par->codec_id == AV_CODEC_ID_DVD_SUBTITLE)
759 else if (track->par->codec_type == AVMEDIA_TYPE_AUDIO)
768 if (track->vos_len) {
770 put_descr(pb, 0x05, track->vos_len);
771 avio_write(pb, track->vos_data, track->vos_len);
796 static int mov_write_ms_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
801 avio_wl32(pb, track->tag); // store it byteswapped
802 track->par->codec_tag = av_bswap16(track->tag >> 16);
803 if ((ret = ff_put_wav_header(s, pb, track->par, 0)) < 0)
808 static int mov_write_wfex_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
814 if ((ret = ff_put_wav_header(s, pb, track->st->codecpar, FF_PUT_WAV_HEADER_FORCE_WAVEFORMATEX)) < 0)
819 static int mov_write_dfla_tag(AVIOContext *pb, MOVTrack *track)
828 if (track->par->extradata_size != FLAC_STREAMINFO_SIZE)
833 avio_wb24(pb, track->par->extradata_size); /* Length */
834 avio_write(pb, track->par->extradata, track->par->extradata_size); /* BlockData[Length] */
839 static int mov_write_dops_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
846 if (track->par->extradata_size < 19) {
853 channels = AV_RB8(track->par->extradata + 9);
854 channel_map = AV_RB8(track->par->extradata + 18);
857 avio_wb16(pb, AV_RL16(track->par->extradata + 10)); /* PreSkip */
858 avio_wb32(pb, AV_RL32(track->par->extradata + 12)); /* InputSampleRate */
859 avio_wb16(pb, AV_RL16(track->par->extradata + 16)); /* OutputGain */
863 if (track->par->extradata_size < 21 + channels) {
867 avio_write(pb, track->par->extradata + 19, 2 + channels); /* ChannelMappingTable */
873 static int mov_write_dmlp_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
880 if (track->vos_len < 20) {
887 length = (AV_RB16(track->vos_data) & 0xFFF) * 2;
888 if (length < 20 || length > track->vos_len)
892 if (AV_RB32(track->vos_data + 4) != 0xF8726FBA)
895 avio_wb32(pb, AV_RB32(track->vos_data + 8)); /* format_info */
896 avio_wb16(pb, AV_RB16(track->vos_data + 18) << 1); /* peak_data_rate */
902 static int mov_write_chan_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
908 if (track->multichannel_as_mono)
911 ret = ff_mov_get_channel_layout_tag(track->par, &layout_tag,
924 if (layout_tag == MOV_CH_LAYOUT_MONO && track->mono_as_fc > 0) {
935 num_desc = layout_tag ? 0 : track->par->ch_layout.nb_channels;
958 static int mov_write_wave_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
965 if (track->par->codec_id != AV_CODEC_ID_QDM2) {
968 avio_wl32(pb, track->tag);
971 if (track->par->codec_id == AV_CODEC_ID_AAC) {
976 mov_write_esds_tag(pb, track);
977 } else if (mov_pcm_le_gt16(track->par->codec_id)) {
979 } else if (mov_pcm_be_gt16(track->par->codec_id)) {
981 } else if (track->par->codec_id == AV_CODEC_ID_AMR_NB) {
982 mov_write_amr_tag(pb, track);
983 } else if (track->par->codec_id == AV_CODEC_ID_AC3) {
984 mov_write_ac3_tag(s, pb, track);
985 } else if (track->par->codec_id == AV_CODEC_ID_EAC3) {
986 mov_write_eac3_tag(s, pb, track);
987 } else if (track->par->codec_id == AV_CODEC_ID_ALAC ||
988 track->par->codec_id == AV_CODEC_ID_QDM2) {
989 mov_write_extradata_tag(pb, track);
990 } else if (track->par->codec_id == AV_CODEC_ID_ADPCM_MS ||
991 track->par->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV) {
992 mov_write_ms_tag(s, pb, track);
1001 static int mov_write_dvc1_structs(MOVTrack *track, uint8_t *buf)
1004 const uint8_t *start, *next, *end = track->vos_data + track->vos_len;
1007 int packet_seq = track->vc1_info.packet_seq;
1008 int packet_entry = track->vc1_info.packet_entry;
1009 int slices = track->vc1_info.slices;
1012 if (track->start_dts == AV_NOPTS_VALUE) {
1021 unescaped = av_mallocz(track->vos_len + AV_INPUT_BUFFER_PADDING_SIZE);
1024 start = find_next_marker(track->vos_data, end);
1072 if (track->st->avg_frame_rate.num > 0 && track->st->avg_frame_rate.den > 0)
1073 put_bits32(&pbc, track->st->avg_frame_rate.num / track->st->avg_frame_rate.den);
1084 static int mov_write_dvc1_tag(AVIOContext *pb, MOVTrack *track)
1089 if ((ret = mov_write_dvc1_structs(track, buf)) < 0)
1092 avio_wb32(pb, track->vos_len + 8 + sizeof(buf));
1095 avio_write(pb, track->vos_data, track->vos_len);
1100 static int mov_write_glbl_tag(AVIOContext *pb, MOVTrack *track)
1102 avio_wb32(pb, track->vos_len + 8);
1104 avio_write(pb, track->vos_data, track->vos_len);
1105 return 8 + track->vos_len;
1137 static int get_cluster_duration(MOVTrack *track, int cluster_idx)
1141 if (cluster_idx >= track->entry)
1144 if (cluster_idx + 1 == track->entry)
1145 next_dts = track->track_duration + track->start_dts;
1147 next_dts = track->cluster[cluster_idx + 1].dts;
1149 next_dts -= track->cluster[cluster_idx].dts;
1157 static int get_samples_per_packet(MOVTrack *track)
1161 // return track->par->frame_size;
1164 if (!track->audio_vbr)
1168 if (!track->entry)
1170 first_duration = get_cluster_duration(track, 0);
1171 for (i = 1; i < track->entry; i++) {
1172 if (get_cluster_duration(track, i) != first_duration)
1178 static int mov_write_btrt_tag(AVIOContext *pb, MOVTrack *track)
1181 struct mpeg4_bit_rate_values bit_rates = calculate_mpeg4_bit_rates(track);
1197 static int mov_write_audio_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
1201 uint32_t tag = track->tag;
1204 if (track->mode == MODE_MOV) {
1205 if (track->timescale > UINT16_MAX || !track->par->ch_layout.nb_channels) {
1206 if (mov_get_lpcm_flags(track->par->codec_id))
1209 } else if (track->audio_vbr || mov_pcm_le_gt16(track->par->codec_id) ||
1210 mov_pcm_be_gt16(track->par->codec_id) ||
1211 track->par->codec_id == AV_CODEC_ID_ADPCM_MS ||
1212 track->par->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV ||
1213 track->par->codec_id == AV_CODEC_ID_QDM2) {
1240 avio_wb64(pb, av_double2int(track->par->sample_rate));
1241 avio_wb32(pb, track->par->ch_layout.nb_channels);
1243 avio_wb32(pb, av_get_bits_per_sample(track->par->codec_id));
1244 avio_wb32(pb, mov_get_lpcm_flags(track->par->codec_id));
1245 avio_wb32(pb, track->sample_size);
1246 avio_wb32(pb, get_samples_per_packet(track));
1248 if (track->mode == MODE_MOV) {
1249 avio_wb16(pb, track->par->ch_layout.nb_channels);
1250 if (track->par->codec_id == AV_CODEC_ID_PCM_U8 ||
1251 track->par->codec_id == AV_CODEC_ID_PCM_S8)
1253 else if (track->par->codec_id == AV_CODEC_ID_ADPCM_G726)
1254 avio_wb16(pb, track->par->bits_per_coded_sample);
1257 avio_wb16(pb, track->audio_vbr ? -2 : 0); /* compression ID */
1259 if (track->par->codec_id == AV_CODEC_ID_FLAC ||
1260 track->par->codec_id == AV_CODEC_ID_ALAC ||
1261 track->par->codec_id == AV_CODEC_ID_OPUS) {
1262 avio_wb16(pb, track->par->ch_layout.nb_channels);
1266 if (track->par->codec_id == AV_CODEC_ID_FLAC ||
1267 track->par->codec_id == AV_CODEC_ID_ALAC) {
1268 avio_wb16(pb, track->par->bits_per_raw_sample);
1276 if (track->par->codec_id == AV_CODEC_ID_OPUS)
1278 else if (track->par->codec_id == AV_CODEC_ID_TRUEHD)
1279 avio_wb32(pb, track->par->sample_rate);
1281 avio_wb16(pb, track->par->sample_rate <= UINT16_MAX ?
1282 track->par->sample_rate : 0);
1284 if (track->par->codec_id != AV_CODEC_ID_TRUEHD)
1289 if (mov_pcm_le_gt16(track->par->codec_id) ||
1290 mov_pcm_be_gt16(track->par->codec_id))
1293 avio_wb32(pb, track->par->frame_size); /* Samples per packet */
1294 avio_wb32(pb, track->sample_size / track->par->ch_layout.nb_channels); /* Bytes per packet */
1295 avio_wb32(pb, track->sample_size); /* Bytes per frame */
1299 if (track->mode == MODE_MOV &&
1300 (track->par->codec_id == AV_CODEC_ID_AAC ||
1301 track->par->codec_id == AV_CODEC_ID_AC3 ||
1302 track->par->codec_id == AV_CODEC_ID_EAC3 ||
1303 track->par->codec_id == AV_CODEC_ID_AMR_NB ||
1304 track->par->codec_id == AV_CODEC_ID_ALAC ||
1305 track->par->codec_id == AV_CODEC_ID_ADPCM_MS ||
1306 track->par->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV ||
1307 track->par->codec_id == AV_CODEC_ID_QDM2 ||
1308 (mov_pcm_le_gt16(track->par->codec_id) && version==1) ||
1309 (mov_pcm_be_gt16(track->par->codec_id) && version==1)))
1310 ret = mov_write_wave_tag(s, pb, track);
1311 else if (track->tag == MKTAG('m','p','4','a'))
1312 ret = mov_write_esds_tag(pb, track);
1313 else if (track->par->codec_id == AV_CODEC_ID_AMR_NB)
1314 ret = mov_write_amr_tag(pb, track);
1315 else if (track->par->codec_id == AV_CODEC_ID_AC3)
1316 ret = mov_write_ac3_tag(s, pb, track);
1317 else if (track->par->codec_id == AV_CODEC_ID_EAC3)
1318 ret = mov_write_eac3_tag(s, pb, track);
1319 else if (track->par->codec_id == AV_CODEC_ID_ALAC)
1320 ret = mov_write_extradata_tag(pb, track);
1321 else if (track->par->codec_id == AV_CODEC_ID_WMAPRO)
1322 ret = mov_write_wfex_tag(s, pb, track);
1323 else if (track->par->codec_id == AV_CODEC_ID_FLAC)
1324 ret = mov_write_dfla_tag(pb, track);
1325 else if (track->par->codec_id == AV_CODEC_ID_OPUS)
1326 ret = mov_write_dops_tag(s, pb, track);
1327 else if (track->par->codec_id == AV_CODEC_ID_TRUEHD)
1328 ret = mov_write_dmlp_tag(s, pb, track);
1329 else if (track->vos_len > 0)
1330 ret = mov_write_glbl_tag(pb, track);
1335 if (track->mode == MODE_MOV && track->par->codec_type == AVMEDIA_TYPE_AUDIO
1336 && ((ret = mov_write_chan_tag(s, pb, track)) < 0)) {
1341 && ((ret = ff_mov_cenc_write_sinf_tag(track, pb, mov->encryption_kid)) < 0)) {
1346 ((ret = mov_write_btrt_tag(pb, track)) < 0))
1365 static int mov_write_av1c_tag(AVIOContext *pb, MOVTrack *track)
1371 ff_isom_write_av1c(pb, track->vos_data, track->vos_len, track->mode != MODE_AVIF);
1375 static int mov_write_avcc_tag(AVIOContext *pb, MOVTrack *track)
1381 ff_isom_write_avcc(pb, track->vos_data, track->vos_len);
1385 static int mov_write_vpcc_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
1393 ff_isom_write_vpcc(s, pb, track->par);
1397 static int mov_write_hvcc_tag(AVIOContext *pb, MOVTrack *track)
1403 if (track->tag == MKTAG('h','v','c','1'))
1404 ff_isom_write_hvcc(pb, track->vos_data, track->vos_len, 1);
1406 ff_isom_write_hvcc(pb, track->vos_data, track->vos_len, 0);
1411 static int mov_write_avid_tag(AVIOContext *pb, MOVTrack *track)
1415 int display_width = track->par->width;
1417 if (track->vos_data && track->vos_len > 0x29) {
1418 if (ff_dnxhd_parse_header_prefix(track->vos_data) != 0) {
1420 interlaced = (track->vos_data[5] & 2);
1421 cid = AV_RB32(track->vos_data + 0x28);
1435 if (track->par->color_range == AVCOL_RANGE_MPEG || /* Legal range (16-235) */
1436 track->par->color_range == AVCOL_RANGE_UNSPECIFIED) {
1443 if (track->tag == MKTAG('A','V','d','h')) {
1467 if ( track->par->sample_aspect_ratio.num > 0
1468 && track->par->sample_aspect_ratio.den > 0)
1469 display_width = display_width * track->par->sample_aspect_ratio.num / track->par->sample_aspect_ratio.den;
1473 avio_wb32(pb, track->par->height / 2);
1478 avio_wb32(pb, track->par->height);
1481 if (track->par->height == 1080)
1492 static int mov_write_dpxe_tag(AVIOContext *pb, MOVTrack *track)
1496 if (track->par->extradata_size >= 12 &&
1497 !memcmp(&track->par->extradata[4], "DpxE", 4)) {
1498 avio_wb32(pb, track->par->extradata[11]);
1505 static int mov_get_dv_codec_tag(AVFormatContext *s, MOVTrack *track)
1509 if (track->par->width == 720) { /* SD */
1510 if (track->par->height == 480) { /* NTSC */
1511 if (track->par->format == AV_PIX_FMT_YUV422P) tag = MKTAG('d','v','5','n');
1513 }else if (track->par->format == AV_PIX_FMT_YUV422P) tag = MKTAG('d','v','5','p');
1514 else if (track->par->format == AV_PIX_FMT_YUV420P) tag = MKTAG('d','v','c','p');
1516 } else if (track->par->height == 720) { /* HD 720 line */
1517 if (track->st->time_base.den == 50) tag = MKTAG('d','v','h','q');
1519 } else if (track->par->height == 1080) { /* HD 1080 line */
1520 if (track->st->time_base.den == 25) tag = MKTAG('d','v','h','5');
1539 static int mov_get_mpeg2_xdcam_codec_tag(AVFormatContext *s, MOVTrack *track)
1541 int tag = track->par->codec_tag;
1542 int interlaced = track->par->field_order > AV_FIELD_PROGRESSIVE;
1543 AVStream *st = track->st;
1549 if (track->par->format == AV_PIX_FMT_YUV420P) {
1550 if (track->par->width == 1280 && track->par->height == 720) {
1558 } else if (track->par->width == 1440 && track->par->height == 1080) {
1567 } else if (track->par->width == 1920 && track->par->height == 1080) {
1577 } else if (track->par->format == AV_PIX_FMT_YUV422P) {
1578 if (track->par->width == 1280 && track->par->height == 720) {
1586 } else if (track->par->width == 1920 && track->par->height == 1080) {
1601 static int mov_get_h264_codec_tag(AVFormatContext *s, MOVTrack *track)
1603 int tag = track->par->codec_tag;
1604 int interlaced = track->par->field_order > AV_FIELD_PROGRESSIVE;
1605 AVStream *st = track->st;
1611 if (track->par->format == AV_PIX_FMT_YUV420P10) {
1612 if (track->par->width == 960 && track->par->height == 720) {
1620 } else if (track->par->width == 1440 && track->par->height == 1080) {
1630 } else if (track->par->format == AV_PIX_FMT_YUV422P10) {
1631 if (track->par->width == 1280 && track->par->height == 720) {
1639 } else if (track->par->width == 1920 && track->par->height == 1080) {
1649 } else if ( track->par->width == 4096 && track->par->height == 2160
1650 || track->par->width == 3840 && track->par->height == 2160
1651 || track->par->width == 2048 && track->par->height == 1080) {
1681 static int mov_get_dnxhd_codec_tag(AVFormatContext *s, MOVTrack *track)
1684 if (track->par->profile != FF_PROFILE_UNKNOWN &&
1685 track->par->profile != FF_PROFILE_DNXHD)
1690 static int mov_get_rawvideo_codec_tag(AVFormatContext *s, MOVTrack *track)
1692 int tag = track->par->codec_tag;
1697 if (track->par->format == mov_pix_fmt_tags[i].pix_fmt) {
1699 track->par->bits_per_coded_sample = mov_pix_fmt_tags[i].bps;
1700 if (track->par->codec_tag == mov_pix_fmt_tags[i].tag)
1706 track->par->bits_per_coded_sample);
1708 track->par->format != pix_fmt &&
1709 track->par->format != AV_PIX_FMT_GRAY8 &&
1710 track->par->format != AV_PIX_FMT_NONE)
1712 av_get_pix_fmt_name(track->par->format));
1716 static unsigned int mov_get_codec_tag(AVFormatContext *s, MOVTrack *track)
1718 unsigned int tag = track->par->codec_tag;
1725 (track->par->codec_id == AV_CODEC_ID_DVVIDEO ||
1726 track->par->codec_id == AV_CODEC_ID_RAWVIDEO ||
1727 track->par->codec_id == AV_CODEC_ID_H263 ||
1728 track->par->codec_id == AV_CODEC_ID_H264 ||
1729 track->par->codec_id == AV_CODEC_ID_DNXHD ||
1730 track->par->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
1731 av_get_bits_per_sample(track->par->codec_id)))) { // pcm audio
1732 if (track->par->codec_id == AV_CODEC_ID_DVVIDEO)
1733 tag = mov_get_dv_codec_tag(s, track);
1734 else if (track->par->codec_id == AV_CODEC_ID_RAWVIDEO)
1735 tag = mov_get_rawvideo_codec_tag(s, track);
1736 else if (track->par->codec_id == AV_CODEC_ID_MPEG2VIDEO)
1737 tag = mov_get_mpeg2_xdcam_codec_tag(s, track);
1738 else if (track->par->codec_id == AV_CODEC_ID_H264)
1739 tag = mov_get_h264_codec_tag(s, track);
1740 else if (track->par->codec_id == AV_CODEC_ID_DNXHD)
1741 tag = mov_get_dnxhd_codec_tag(s, track);
1742 else if (track->par->codec_type == AVMEDIA_TYPE_VIDEO) {
1743 tag = ff_codec_get_tag(ff_codec_movvideo_tags, track->par->codec_id);
1745 tag = ff_codec_get_tag(ff_codec_bmp_tags, track->par->codec_id);
1750 } else if (track->par->codec_type == AVMEDIA_TYPE_AUDIO) {
1751 tag = ff_codec_get_tag(ff_codec_movaudio_tags, track->par->codec_id);
1753 int ms_tag = ff_codec_get_tag(ff_codec_wav_tags, track->par->codec_id);
1760 } else if (track->par->codec_type == AVMEDIA_TYPE_SUBTITLE)
1761 tag = ff_codec_get_tag(ff_codec_movsubtitle_tags, track->par->codec_id);
1794 static unsigned int mov_find_codec_tag(AVFormatContext *s, MOVTrack *track)
1796 if (is_cover_image(track->st))
1797 return ff_codec_get_tag(codec_cover_image_tags, track->par->codec_id);
1799 if (track->mode == MODE_IPOD)
1806 if (track->mode == MODE_MOV) {
1807 return mov_get_codec_tag(s, track);
1809 return validate_codec_tag(s->oformat->codec_tag, track->par->codec_tag,
1810 track->par->codec_id);
1833 static int mov_write_fiel_tag(AVIOContext *pb, MOVTrack *track, int field_order)
1846 static int mov_write_subtitle_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
1852 avio_wl32(pb, track->tag); // store it byteswapped
1857 if (track->par->codec_id == AV_CODEC_ID_DVD_SUBTITLE)
1858 mov_write_esds_tag(pb, track);
1859 else if (track->par->codec_id == AV_CODEC_ID_TTML) {
1860 switch (track->par->codec_tag) {
1876 "index %d (track id %d)!\n",
1877 av_fourcc2str(track->par->codec_tag), track->st->index,
1878 track->track_id);
1881 } else if (track->par->extradata_size)
1882 avio_write(pb, track->par->extradata, track->par->extradata_size);
1885 ((ret = mov_write_btrt_tag(pb, track)) < 0))
1997 static int mov_write_clap_tag(AVIOContext *pb, MOVTrack *track)
2001 avio_wb32(pb, track->par->width); /* apertureWidth_N */
2003 avio_wb32(pb, track->height); /* apertureHeight_N */
2012 static int mov_write_pasp_tag(AVIOContext *pb, MOVTrack *track)
2015 av_reduce(&sar.num, &sar.den, track->par->sample_aspect_ratio.num,
2016 track->par->sample_aspect_ratio.den, INT_MAX);
2025 static int mov_write_gama_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track, double gamma)
2029 gamma = avpriv_get_gamma_from_trc(track->par->color_trc);
2037 av_assert0(track->mode == MODE_MOV);
2048 static int mov_write_colr_tag(AVIOContext *pb, MOVTrack *track, int prefer_icc)
2059 icc_profile = av_stream_get_side_data(track->st, AV_PKT_DATA_ICC_PROFILE, &icc_profile_size);
2074 av_assert0(track->mode == MODE_MOV || track->mode == MODE_MP4 ||
2075 track->mode == MODE_AVIF);
2079 if (track->mode == MODE_MP4 || track->mode == MODE_AVIF)
2086 avio_wb16(pb, track->par->color_primaries);
2087 avio_wb16(pb, track->par->color_trc);
2088 avio_wb16(pb, track->par->color_space);
2089 if (track->mode == MODE_MP4 || track->mode == MODE_AVIF) {
2090 int full_range = track->par->color_range == AVCOL_RANGE_JPEG;
2114 static int mov_write_clli_tag(AVIOContext *pb, MOVTrack *track)
2119 side_data = av_stream_get_side_data(track->st, AV_PKT_DATA_CONTENT_LIGHT_LEVEL, NULL);
2137 static int mov_write_mdcv_tag(AVIOContext *pb, MOVTrack *track)
2144 side_data = av_stream_get_side_data(track->st, AV_PKT_DATA_MASTERING_DISPLAY_METADATA, NULL);
2165 static void find_compressor(char * compressor_name, int len, MOVTrack *track)
2168 int xdcam_res = (track->par->width == 1280 && track->par->height == 720)
2169 || (track->par->width == 1440 && track->par->height == 1080)
2170 || (track->par->width == 1920 && track->par->height == 1080);
2172 if ((track->mode == MODE_AVIF ||
2173 track->mode == MODE_MOV ||
2174 track->mode == MODE_MP4) &&
2175 (encoder = av_dict_get(track->st->metadata, "encoder", NULL, 0))) {
2177 } else if (track->par->codec_id == AV_CODEC_ID_MPEG2VIDEO && xdcam_res) {
2178 int interlaced = track->par->field_order > AV_FIELD_PROGRESSIVE;
2179 AVStream *st = track->st;
2182 if (track->par->format == AV_PIX_FMT_YUV422P) {
2184 } else if(track->par->width == 1440) {
2189 av_strlcatf(compressor_name, len, " %d%c", track->par->height, interlaced ? 'i' : 'p');
2215 static CuvaConfig mov_get_cuva_from_metadata(AVFormatContext *s, MOVMuxContext *mov, MOVTrack *track)
2221 if (s == NULL || mov == NULL || track == NULL) {
2228 if (track == &mov->tracks[i]) {
2233 av_log(mov->fc, AV_LOG_WARNING, "Not cuva info. The track is not in the mov!\n");
2250 static int mov_write_metadata_setup_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
2255 AVDictionaryEntry* key_val = av_dict_get(track->st->metadata, "setup_key", NULL, 0);
2263 static int mov_write_metadata_locale_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
2268 AVDictionaryEntry* key_val = av_dict_get(track->st->metadata, "locale_key", NULL, 0);
2287 static int mov_write_metadata_keys_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
2302 while (t = av_dict_get(track->st->metadata, "", t, AV_DICT_IGNORE_SUFFIX)) {
2319 static int mov_write_mebx_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
2325 ret = mov_write_metadata_keys_tag(s, pb, mov, track);
2333 static int mov_write_video_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
2340 int uncompressed_ycbcr = ((track->par->codec_id == AV_CODEC_ID_RAWVIDEO && track->par->format == AV_PIX_FMT_UYVY422)
2341 || (track->par->codec_id == AV_CODEC_ID_RAWVIDEO && track->par->format == AV_PIX_FMT_YUYV422)
2342 || track->par->codec_id == AV_CODEC_ID_V308
2343 || track->par->codec_id == AV_CODEC_ID_V408
2344 || track->par->codec_id == AV_CODEC_ID_V410
2345 || track->par->codec_id == AV_CODEC_ID_V210);
2351 avio_wl32(pb, track->tag); // store it byteswapped
2363 if (track->mode == MODE_MOV) {
2365 if (track->par->codec_id == AV_CODEC_ID_RAWVIDEO || uncompressed_ycbcr) {
2375 avio_wb16(pb, track->par->width); /* Video width */
2376 avio_wb16(pb, track->height); /* Video height */
2382 find_compressor(compressor_name, 32, track);
2384 CuvaConfig cuva = mov_get_cuva_from_metadata(s, mov, track);
2385 if (cuva.cuva_version_map > 0 && track->par->codec_id == AV_CODEC_ID_HEVC) {
2393 if (track->mode == MODE_MOV &&
2394 (track->par->codec_id == AV_CODEC_ID_V410 || track->par->codec_id == AV_CODEC_ID_V210))
2396 else if (track->mode == MODE_MOV && track->par->bits_per_coded_sample)
2397 avio_wb16(pb, track->par->bits_per_coded_sample |
2398 (track->par->format == AV_PIX_FMT_GRAY8 ? 0x20 : 0));
2402 if (track->mode == MODE_MOV && track->par->format == AV_PIX_FMT_PAL8) {
2407 if (track->par->bits_per_coded_sample < 0 || track->par->bits_per_coded_sample > 8)
2409 pal_size = 1 << track->par->bits_per_coded_sample;
2412 uint32_t rgb = track->palette[i];
2424 if (track->tag == MKTAG('m','p','4','v'))
2425 mov_write_esds_tag(pb, track);
2426 else if (track->par->codec_id == AV_CODEC_ID_H263)
2428 else if (track->par->codec_id == AV_CODEC_ID_AVUI ||
2429 track->par->codec_id == AV_CODEC_ID_SVQ3) {
2430 mov_write_extradata_tag(pb, track);
2432 } else if (track->par->codec_id == AV_CODEC_ID_DNXHD) {
2433 mov_write_avid_tag(pb, track);
2435 } else if (track->par->codec_id == AV_CODEC_ID_HEVC)
2436 mov_write_hvcc_tag(pb, track);
2437 else if (track->par->codec_id == AV_CODEC_ID_H264 && !TAG_IS_AVCI(track->tag)) {
2438 mov_write_avcc_tag(pb, track);
2439 if (track->mode == MODE_IPOD)
2441 } else if (track->par->codec_id == AV_CODEC_ID_VP9) {
2442 mov_write_vpcc_tag(mov->fc, pb, track);
2443 } else if (track->par->codec_id == AV_CODEC_ID_AV1) {
2444 mov_write_av1c_tag(pb, track);
2445 } else if (track->par->codec_id == AV_CODEC_ID_VC1 && track->vos_len > 0)
2446 mov_write_dvc1_tag(pb, track);
2447 else if (track->par->codec_id == AV_CODEC_ID_VP6F ||
2448 track->par->codec_id == AV_CODEC_ID_VP6A) {
2451 } else if (track->par->codec_id == AV_CODEC_ID_R10K) {
2452 if (track->par->codec_tag == MKTAG('R','1','0','k'))
2453 mov_write_dpxe_tag(pb, track);
2454 } else if (track->vos_len > 0)
2455 mov_write_glbl_tag(pb, track);
2457 if (track->par->codec_id != AV_CODEC_ID_H264 &&
2458 track->par->codec_id != AV_CODEC_ID_MPEG4 &&
2459 track->par->codec_id != AV_CODEC_ID_DNXHD) {
2460 int field_order = track->par->field_order;
2463 mov_write_fiel_tag(pb, track, field_order);
2467 if (track->mode == MODE_MOV)
2468 mov_write_gama_tag(s, pb, track, mov->gamma);
2472 if (track->mode == MODE_MOV || track->mode == MODE_MP4 || track->mode == MODE_AVIF) {
2473 int has_color_info = track->par->color_primaries != AVCOL_PRI_UNSPECIFIED &&
2474 track->par->color_trc != AVCOL_TRC_UNSPECIFIED &&
2475 track->par->color_space != AVCOL_SPC_UNSPECIFIED;
2477 av_stream_get_side_data(track->st, AV_PKT_DATA_ICC_PROFILE, NULL)) {
2479 mov_write_colr_tag(pb, track, prefer_icc);
2484 if (track->mode == MODE_MOV || track->mode == MODE_MP4) {
2485 mov_write_clli_tag(pb, track);
2486 mov_write_mdcv_tag(pb, track);
2489 if (track->mode == MODE_MP4 && mov->fc->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
2490 AVStereo3D* stereo_3d = (AVStereo3D*) av_stream_get_side_data(track->st, AV_PKT_DATA_STEREO3D, NULL);
2491 AVSphericalMapping* spherical_mapping = (AVSphericalMapping*)av_stream_get_side_data(track->st, AV_PKT_DATA_SPHERICAL, NULL);
2493 av_stream_get_side_data(track->st, AV_PKT_DATA_DOVI_CONF, NULL);
2503 if (track->par->sample_aspect_ratio.den && track->par->sample_aspect_ratio.num) {
2504 mov_write_pasp_tag(pb, track);
2508 mov_write_clap_tag(pb, track);
2512 ff_mov_cenc_write_sinf_tag(track, pb, mov->encryption_kid);
2516 if (cuva.cuva_version_map > 0 && track->par->codec_id == AV_CODEC_ID_HEVC) {
2522 ((ret = mov_write_btrt_tag(pb, track)) < 0))
2530 if (track->mode == MODE_AVIF)
2536 static int mov_write_rtp_tag(AVIOContext *pb, MOVTrack *track)
2545 avio_wb16(pb, 1); /* Hint track version */
2547 avio_wb32(pb, track->max_packet_size); /* Max packet size */
2551 avio_wb32(pb, track->timescale);
2556 static int mov_write_source_reference_tag(AVIOContext *pb, MOVTrack *track, const char *reel_name)
2570 avio_wb16(pb, track->language); /* langcode */
2575 static int mov_write_tmcd_tag(AVIOContext *pb, MOVTrack *track)
2583 if (!track->st->avg_frame_rate.num || !track->st->avg_frame_rate.den) {
2584 av_log(NULL, AV_LOG_ERROR, "avg_frame_rate not set for tmcd track.\n");
2587 frame_duration = av_rescale(track->timescale, track->st->avg_frame_rate.den, track->st->avg_frame_rate.num);
2588 nb_frames = ROUNDED_DIV(track->st->avg_frame_rate.num, track->st->avg_frame_rate.den);
2601 avio_wb32(pb, track->timecode_flags); /* Flags (timecode) */
2602 avio_wb32(pb, track->timescale); /* Timescale */
2607 t = av_dict_get(track->st->metadata, "reel_name", NULL, 0);
2608 if (t && utf8len(t->value) && track->mode != MODE_MP4)
2609 mov_write_source_reference_tag(pb, track, t->value);
2618 if (track->par->extradata_size)
2619 avio_write(pb, track->par->extradata, track->par->extradata_size);
2624 static int mov_write_gpmd_tag(AVIOContext *pb, const MOVTrack *track)
2636 static int mov_write_stsd_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
2644 if (track->par->codec_type == AVMEDIA_TYPE_VIDEO)
2645 ret = mov_write_video_tag(s, pb, mov, track);
2646 else if (track->par->codec_type == AVMEDIA_TYPE_AUDIO)
2647 ret = mov_write_audio_tag(s, pb, mov, track);
2648 else if (track->par->codec_type == AVMEDIA_TYPE_SUBTITLE)
2649 ret = mov_write_subtitle_tag(s, pb, track);
2650 else if (track->par->codec_tag == MKTAG('r','t','p',' '))
2651 ret = mov_write_rtp_tag(pb, track);
2652 else if (track->par->codec_tag == MKTAG('t','m','c','d'))
2653 ret = mov_write_tmcd_tag(pb, track);
2654 else if (track->par->codec_tag == MKTAG('g','p','m','d'))
2655 ret = mov_write_gpmd_tag(pb, track);
2657 else if (track->par->codec_type == AVMEDIA_TYPE_TIMEDMETA)
2658 ret = mov_write_mebx_tag(s, pb, mov, track);
2667 static int mov_write_ctts_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
2675 ctts_entries = av_malloc_array((track->entry + 1), sizeof(*ctts_entries)); /* worst case */
2679 ctts_entries[0].duration = track->cluster[0].cts;
2680 for (i = 1; i < track->entry; i++) {
2681 if (track->cluster[i].cts == ctts_entries[entries].duration) {
2685 ctts_entries[entries].duration = track->cluster[i].cts;
2708 static int mov_write_stts_tag(AVIOContext *pb, MOVTrack *track)
2715 if (track->par->codec_type == AVMEDIA_TYPE_AUDIO && !track->audio_vbr) {
2719 stts_entries[0].count = track->sample_count;
2723 if (track->entry) {
2724 stts_entries = av_malloc_array(track->entry, sizeof(*stts_entries)); /* worst case */
2728 for (i = 0; i < track->entry; i++) {
2729 int duration = get_cluster_duration(track, i);
2768 static int mov_preroll_write_stbl_atoms(AVIOContext *pb, MOVTrack *track)
2786 if (!track->entry)
2789 sgpd_entries = av_malloc_array(track->entry, sizeof(*sgpd_entries));
2793 av_assert0(track->par->codec_id == AV_CODEC_ID_OPUS || track->par->codec_id == AV_CODEC_ID_AAC);
2795 if (track->par->codec_id == AV_CODEC_ID_OPUS) {
2796 for (i = 0; i < track->entry; i++) {
2800 roll_samples_remaining -= get_cluster_duration(track, j);
2824 sgpd_entries[entries].count = track->sample_count;
2863 static int mov_write_stbl_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
2870 if ((ret = mov_write_stsd_tag(s, pb, mov, track)) < 0)
2872 mov_write_stts_tag(pb, track);
2873 if ((track->par->codec_type == AVMEDIA_TYPE_VIDEO ||
2874 track->par->codec_id == AV_CODEC_ID_TRUEHD ||
2875 track->par->codec_id == AV_CODEC_ID_MPEGH_3D_AUDIO ||
2877 track->par->codec_tag == MKTAG('r','t','p',' ') ||
2878 track->par->codec_type == AVMEDIA_TYPE_TIMEDMETA) &&
2880 track->par->codec_tag == MKTAG('r','t','p',' ')) &&
2882 track->has_keyframes && track->has_keyframes < track->entry)
2883 mov_write_stss_tag(pb, track, MOV_SYNC_SAMPLE);
2884 if (track->par->codec_type == AVMEDIA_TYPE_VIDEO && track->has_disposable)
2885 mov_write_sdtp_tag(pb, track);
2886 if (track->mode == MODE_MOV && track->flags & MOV_TRACK_STPS)
2887 mov_write_stss_tag(pb, track, MOV_PARTIAL_SYNC_SAMPLE);
2888 if (track->par->codec_type == AVMEDIA_TYPE_VIDEO &&
2889 track->flags & MOV_TRACK_CTTS && track->entry) {
2891 if ((ret = mov_write_ctts_tag(s, pb, track)) < 0)
2894 mov_write_stsc_tag(pb, track);
2895 mov_write_stsz_tag(pb, track);
2896 mov_write_stco_tag(pb, track);
2897 if (track->cenc.aes_ctr) {
2898 ff_mov_cenc_write_stbl_atoms(&track->cenc, pb);
2900 if (track->par->codec_id == AV_CODEC_ID_OPUS || track->par->codec_id == AV_CODEC_ID_AAC) {
2901 mov_preroll_write_stbl_atoms(pb, track);
2931 static int mov_write_tcmi_tag(AVIOContext *pb, MOVTrack *track)
2953 static int mov_write_gmhd_tag(AVIOContext *pb, MOVTrack *track)
2974 if (track->tag != MKTAG('c','6','0','8')) {
2989 if (track->par->codec_tag == MKTAG('t','m','c','d')) {
2993 mov_write_tcmi_tag(pb, track);
2995 } else if (track->par->codec_tag == MKTAG('g','p','m','d')) {
3024 static int is_clcp_track(MOVTrack *track)
3026 return track->tag == MKTAG('c','7','0','8') ||
3027 track->tag == MKTAG('c','6','0','8');
3030 static int mov_write_hdlr_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
3041 if (track) {
3042 hdlr = (track->mode == MODE_MOV) ? "mhlr" : "\0\0\0\0";
3043 if (track->par->codec_type == AVMEDIA_TYPE_VIDEO) {
3044 if (track->mode == MODE_AVIF) {
3045 hdlr_type = (track == &mov->tracks[0]) ? "pict" : "auxv";
3051 } else if (track->par->codec_type == AVMEDIA_TYPE_AUDIO) {
3054 } else if (track->par->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3055 if (is_clcp_track(track)) {
3059 if (track->tag == MKTAG('t','x','3','g')) {
3061 } else if (track->tag == MKTAG('m','p','4','s')) {
3063 } else if (track->tag == MOV_MP4_TTML_TAG) {
3070 } else if (track->par->codec_tag == MKTAG('r','t','p',' ')) {
3073 } else if (track->par->codec_tag == MKTAG('t','m','c','d')) {
3076 } else if (track->par->codec_tag == MKTAG('g','p','m','d')) {
3080 } else if (track->par->codec_type == AVMEDIA_TYPE_TIMEDMETA) {
3086 av_fourcc2str(track->par->codec_tag));
3088 if (track->st) {
3090 // of the track. So if an alternate handler description is
3093 t = av_dict_get(track->st->metadata, "handler_name", NULL, 0);
3111 if (!track || track->mode == MODE_MOV)
3114 if (track && track->mode != MODE_MOV)
3300 static int mov_write_minf_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
3307 if (track->par->codec_type == AVMEDIA_TYPE_VIDEO)
3309 else if (track->par->codec_type == AVMEDIA_TYPE_AUDIO)
3311 else if (track->par->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3312 if (track->tag == MKTAG('t','e','x','t') || is_clcp_track(track)) {
3313 mov_write_gmhd_tag(pb, track);
3314 } else if (track->tag == MOV_MP4_TTML_TAG) {
3319 } else if (track->tag == MKTAG('r','t','p',' ')) {
3321 } else if (track->tag == MKTAG('t','m','c','d')) {
3322 if (track->mode != MODE_MOV)
3325 mov_write_gmhd_tag(pb, track);
3326 } else if (track->tag == MKTAG('g','p','m','d')) {
3327 mov_write_gmhd_tag(pb, track);
3329 if (track->mode == MODE_MOV) /* ISO 14496-12 8.4.3.1 specifies hdlr only within mdia or meta boxes */
3332 if ((ret = mov_write_stbl_tag(s, pb, mov, track)) < 0)
3337 static void get_pts_range(MOVMuxContext *mov, MOVTrack *track,
3341 if ((track->tag == MKTAG('t','m','c','d') && mov->nb_meta_tmcd) ||
3342 (track->tag == MKTAG('c','d','s','c'))) {
3344 if (track->tag == MKTAG('t','m','c','d') && mov->nb_meta_tmcd) {
3347 // another track's duration, while the end_pts may be left at zero.
3348 // Calculate the pts duration for that track instead.
3349 get_pts_range(mov, &mov->tracks[track->src_track], start, end);
3350 *start = av_rescale(*start, track->timescale,
3351 mov->tracks[track->src_track].timescale);
3352 *end = av_rescale(*end, track->timescale,
3353 mov->tracks[track->src_track].timescale);
3356 if (track->end_pts != AV_NOPTS_VALUE &&
3357 track->start_dts != AV_NOPTS_VALUE &&
3358 track->start_cts != AV_NOPTS_VALUE) {
3359 *start = track->start_dts + track->start_cts;
3360 *end = track->end_pts;
3364 *end = track->track_duration;
3367 static int64_t calc_samples_pts_duration(MOVMuxContext *mov, MOVTrack *track)
3370 get_pts_range(mov, track, &start, &end);
3374 // Calculate the actual duration of the track, after edits.
3379 static int64_t calc_pts_duration(MOVMuxContext *mov, MOVTrack *track)
3382 get_pts_range(mov, track, &start, &end);
3389 MOVTrack *track)
3391 int64_t duration = calc_samples_pts_duration(mov, track);
3394 if (track->mode == MODE_ISM)
3402 avio_wb64(pb, track->time);
3403 avio_wb64(pb, track->time);
3405 avio_wb32(pb, track->time); /* creation time */
3406 avio_wb32(pb, track->time); /* modification time */
3408 avio_wb32(pb, track->timescale); /* time scale (sample rate for audio) */
3409 if (!track->entry && mov->mode == MODE_ISM)
3411 else if (!track->entry)
3415 avio_wb16(pb, track->language); /* language */
3418 if (version != 0 && track->mode == MODE_MOV) {
3429 MOVMuxContext *mov, MOVTrack *track)
3436 mov_write_mdhd_tag(pb, mov, track);
3437 mov_write_hdlr_tag(s, pb, track);
3438 if ((ret = mov_write_minf_tag(s, pb, mov, track)) < 0)
3462 MOVTrack *track, AVStream *st)
3464 int64_t duration = av_rescale_rnd(calc_pts_duration(mov, track),
3465 mov->movie_timescale, track->timescale,
3487 if (track->flags & MOV_TRACK_ENABLED)
3490 if (track->mode == MODE_ISM)
3498 avio_wb64(pb, track->time);
3499 avio_wb64(pb, track->time);
3501 avio_wb32(pb, track->time); /* creation time */
3502 avio_wb32(pb, track->time); /* modification time */
3504 avio_wb32(pb, track->track_id); /* track-id */
3506 if (!track->entry && mov->mode == MODE_ISM)
3508 else if (!track->entry)
3518 if (track->par->codec_type == AVMEDIA_TYPE_AUDIO)
3532 if (st && (track->par->codec_type == AVMEDIA_TYPE_VIDEO ||
3533 track->par->codec_type == AVMEDIA_TYPE_SUBTITLE)) {
3535 if (track->mode == MODE_MOV || track->mode == MODE_AVIF) {
3536 track_width_1616 = track->par->width * 0x10000ULL;
3539 track->par->width * 0x10000LL,
3542 track->height != track->par->height ||
3544 track_width_1616 = track->par->width * 0x10000ULL;
3547 av_log(mov->fc, AV_LOG_WARNING, "track width is too large\n");
3551 if (track->height > 0xFFFF) {
3552 av_log(mov->fc, AV_LOG_WARNING, "track height is too large\n");
3555 avio_wb32(pb, track->height * 0x10000U);
3563 static int mov_write_tapt_tag(AVIOContext *pb, MOVTrack *track)
3565 int32_t width = av_rescale(track->par->sample_aspect_ratio.num, track->par->width,
3566 track->par->sample_aspect_ratio.den);
3577 avio_wb32(pb, track->par->height << 16);
3583 avio_wb32(pb, track->par->height << 16);
3588 avio_wb32(pb, track->par->width << 16);
3589 avio_wb32(pb, track->par->height << 16);
3596 MOVTrack *track)
3598 int64_t duration = av_rescale_rnd(calc_samples_pts_duration(mov, track),
3599 mov->movie_timescale, track->timescale,
3603 int64_t delay, start_ct = track->start_cts;
3604 int64_t start_dts = track->start_dts;
3606 if (track->entry) {
3607 if (start_dts != track->cluster[0].dts || start_ct != track->cluster[0].cts) {
3611 track->cluster[0].dts, track->cluster[0].cts,
3612 start_dts, start_ct, track->track_id);
3613 start_dts = track->cluster[0].dts;
3614 start_ct = track->cluster[0].cts;
3619 track->timescale, AV_ROUND_DOWN);
3654 av_assert0(av_rescale_rnd(start_dts, mov->movie_timescale, track->timescale, AV_ROUND_DOWN) <= 0);
3681 static int mov_write_tref_tag(AVIOContext *pb, MOVTrack *track)
3690 avio_wl32(pb, track->tref_tag);
3691 for (tref_index = 0; tref_index < track->ref_track_count; tref_index++) {
3692 avio_wb32(pb, track->tref_ids[tref_index]);
3700 avio_wl32(pb, track->tref_tag);
3701 avio_wb32(pb, track->tref_id);
3706 // goes at the end of each track! ... Critical for PSP playback ("Incompatible data" without it)
3725 static int mov_write_udta_sdp(AVIOContext *pb, MOVTrack *track)
3727 AVFormatContext *ctx = track->rtp_ctx;
3731 ff_sdp_write_media(buf, sizeof(buf), ctx->streams[0], track->src_track,
3733 av_strlcatf(buf, sizeof(buf), "a=control:streamid=%d\r\n", track->track_id);
3839 MOVTrack *track, AVStream *st)
3842 int entry_backup = track->entry;
3843 int chunk_backup = track->chunkCount;
3849 track->chunkCount = track->entry = 0;
3853 mov_write_tkhd_tag(pb, mov, track, st);
3857 if (track->start_dts != AV_NOPTS_VALUE) {
3859 mov_write_edts_tag(pb, mov, track); // PSP Movies and several other cases require edts box
3860 else if ((track->entry && track->cluster[0].dts) || track->mode == MODE_PSP || is_clcp_track(track))
3865 if (track->tref_tag)
3866 mov_write_tref_tag(pb, track);
3868 if ((ret = mov_write_mdia_tag(s, pb, mov, track)) < 0)
3870 if (track->mode == MODE_PSP)
3871 mov_write_uuid_tag_psp(pb, track); // PSP Movies require this uuid box
3872 if (track->tag == MKTAG('r','t','p',' '))
3873 mov_write_udta_sdp(pb, track);
3874 if (track->mode == MODE_MOV) {
3875 if (track->par->codec_type == AVMEDIA_TYPE_VIDEO) {
3878 mov_write_tapt_tag(pb, track);
3881 if (is_clcp_track(track) && st->sample_aspect_ratio.num) {
3882 mov_write_tapt_tag(pb, track);
3886 track->entry = entry_backup;
3887 track->chunkCount = chunk_backup;
3920 static int mov_write_trex_tag(AVIOContext *pb, MOVTrack *track)
3925 avio_wb32(pb, track->track_id); /* track ID */
3990 (version == 1) ? avio_wb64(pb, max_track_len) : avio_wb32(pb, max_track_len); /* duration of longest track */
4005 avio_wb32(pb, max_track_id + 1); /* Next track id */
4315 /* iTunes track or disc number */
4320 disc ? "disc" : "track",
4322 int size = 0, track = t ? atoi(t->value) : 0;
4323 if (track) {
4335 avio_wb16(pb, track); // track / disc number
4336 avio_wb16(pb, tracks); // total track / disc number
4432 mov_write_trkn_tag(pb, mov, s, 0); // track number
4518 // We always write the primary item id as 1 since only one track is
4665 (t = av_dict_get(s->metadata, "track", NULL, 0)))
4835 * Assign track ids. If option "use_stream_ids_as_track_ids" is set,
4836 * the stream ids are used as track ids.
4843 * s->streams than in mov->tracks, in which case new track ids are
4911 MOVTrack *track = &mov->tracks[i];
4912 if (track->tag == MKTAG('r','t','p',' ')) {
4913 track->tref_tag = MKTAG('h','i','n','t');
4915 track->ref_track_count++;
4916 track->tref_ids[0] = mov->tracks[track->src_track].track_id;
4918 track->tref_id = mov->tracks[track->src_track].track_id;
4920 } else if (track->par->codec_type == AVMEDIA_TYPE_AUDIO) {
4923 fallback = (int*)av_stream_get_side_data(track->st,
4928 track->tref_tag = MKTAG('f','a','l','l');
4930 track->ref_track_count++;
4931 track->tref_ids[0] = mov->tracks[*fallback].track_id;
4933 track->tref_id = mov->tracks[*fallback].track_id;
4949 //src_trk may have a different timescale than the tmcd track
5041 MOVTrack *track = &mov->tracks[i];
5043 calculate_mpeg4_bit_rates(track);
5045 int track_id = track->track_id;
5048 AVStream *st = track->st;
5051 if (track->par->codec_type == AVMEDIA_TYPE_VIDEO && !is_cover_image(st)) {
5053 } else if (track->par->codec_type == AVMEDIA_TYPE_AUDIO) {
5065 /* Build track name piece by piece: */
5066 /* 1. track type */
5068 /* 2. track language, if available */
5081 if (track->par->codec_type == AVMEDIA_TYPE_VIDEO) {
5082 if (track->par->codec_id == AV_CODEC_ID_H264) {
5084 int size = track->par->extradata_size;
5085 if (!ff_avc_write_annexb_extradata(track->par->extradata, &ptr,
5088 ptr ? ptr : track->par->extradata,
5093 } else if (track->par->codec_id == AV_CODEC_ID_VC1) {
5095 param_write_hex(pb, "CodecPrivateData", track->par->extradata,
5096 track->par->extradata_size);
5098 param_write_int(pb, "MaxWidth", track->par->width);
5099 param_write_int(pb, "MaxHeight", track->par->height);
5100 param_write_int(pb, "DisplayWidth", track->par->width);
5101 param_write_int(pb, "DisplayHeight", track->par->height);
5103 if (track->par->codec_id == AV_CODEC_ID_AAC) {
5104 switch (track->par->profile)
5115 } else if (track->par->codec_id == AV_CODEC_ID_WMAPRO) {
5118 param_write_hex(pb, "CodecPrivateData", track->par->extradata,
5119 track->par->extradata_size);
5121 track->par->codec_id));
5122 param_write_int(pb, "Channels", track->par->ch_layout.nb_channels);
5123 param_write_int(pb, "SamplingRate", track->par->sample_rate);
5125 param_write_int(pb, "PacketSize", track->par->block_align ?
5126 track->par->block_align : 4);
5146 static uint32_t get_sample_flags(MOVTrack *track, MOVIentry *entry)
5153 MOVTrack *track, int64_t moof_offset)
5158 if (!track->entry) {
5177 if (track->mode == MODE_ISM)
5186 avio_wb32(pb, track->track_id); /* track-id */
5193 track->default_duration = get_cluster_duration(track, 0);
5194 avio_wb32(pb, track->default_duration);
5197 track->default_size = track->entry ? track->cluster[0].size : 1;
5198 avio_wb32(pb, track->default_size);
5200 track->default_size = -1;
5205 if (track->entry > 1)
5206 track->default_sample_flags = get_sample_flags(track, &track->cluster[1]);
5208 track->default_sample_flags =
5209 track->par->codec_type == AVMEDIA_TYPE_VIDEO ?
5212 avio_wb32(pb, track->default_sample_flags);
5219 MOVTrack *track, int moof_size,
5227 if (get_cluster_duration(track, i) != track->default_duration)
5229 if (track->cluster[i].size != track->default_size)
5231 if (i > first && get_sample_flags(track, &track->cluster[i]) != track->default_sample_flags)
5234 if (!(flags & MOV_TRUN_SAMPLE_FLAGS) && track->entry > 0 &&
5235 get_sample_flags(track, &track->cluster[0]) != track->default_sample_flags)
5237 if (track->flags & MOV_TRACK_CTTS)
5254 avio_wb32(pb, moof_size + 8 + track->data_offset +
5255 track->cluster[first].pos); /* data offset */
5257 avio_wb32(pb, get_sample_flags(track, &track->cluster[first]));
5261 avio_wb32(pb, get_cluster_duration(track, i));
5263 avio_wb32(pb, track->cluster[i].size);
5265 avio_wb32(pb, get_sample_flags(track, &track->cluster[i]));
5267 avio_wb32(pb, track->cluster[i].cts);
5274 static int mov_write_tfxd_tag(AVIOContext *pb, MOVTrack *track)
5287 avio_wb64(pb, track->cluster[0].dts + track->cluster[0].cts);
5288 avio_wb64(pb, track->end_pts -
5289 (track->cluster[0].dts + track->cluster[0].cts));
5295 MOVTrack *track, int entry)
5297 int n = track->nb_frag_info - 1 - entry, i;
5307 avio_seek(pb, track->frag_info[entry].tfrf_offset, SEEK_SET);
5316 avio_wb64(pb, track->frag_info[index].time);
5317 avio_wb64(pb, track->frag_info[index].duration);
5330 MOVTrack *track)
5337 mov_write_tfrf_tag(pb, mov, track, track->nb_frag_info - 2 - i);
5348 MOVTrack *track = &mov->tracks[i];
5350 if ((tracks >= 0 && i != tracks) || !track->entry)
5352 track->nb_frag_info++;
5353 if (track->nb_frag_info >= track->frag_info_capacity) {
5354 unsigned new_capacity = track->nb_frag_info + MOV_FRAG_INFO_ALLOC_INCREMENT;
5355 if (av_reallocp_array(&track->frag_info,
5357 sizeof(*track->frag_info)))
5359 track->frag_info_capacity = new_capacity;
5361 info = &track->frag_info[track->nb_frag_info - 1];
5366 info->time = track->cluster[0].dts + track->cluster[0].cts;
5367 info->duration = track->end_pts -
5368 (track->cluster[0].dts + track->cluster[0].cts);
5370 // away parts of the media track using an edit list,
5377 mov_write_tfrf_tags(pb, mov, track);
5386 MOVTrack *track = &mov->tracks[i];
5387 if ((tracks >= 0 && i != tracks) || !track->entry)
5389 if (track->nb_frag_info > max) {
5390 memmove(track->frag_info, track->frag_info + (track->nb_frag_info - max), max * sizeof(*track->frag_info));
5391 track->nb_frag_info = max;
5396 static int mov_write_tfdt_tag(AVIOContext *pb, MOVTrack *track)
5404 avio_wb64(pb, track->cluster[0].dts - track->start_dts);
5409 MOVTrack *track, int64_t moof_offset,
5417 mov_write_tfhd_tag(pb, mov, track, moof_offset);
5419 mov_write_tfdt_tag(pb, track);
5420 for (i = 1; i < track->entry; i++) {
5421 if (track->cluster[i].pos != track->cluster[i - 1].pos + track->cluster[i - 1].size) {
5422 mov_write_trun_tag(pb, mov, track, moof_size, start, i);
5426 mov_write_trun_tag(pb, mov, track, moof_size, start, track->entry);
5428 mov_write_tfxd_tag(pb, track);
5433 if (track->nb_frag_info > 0) {
5434 MOVFragmentInfo *info = &track->frag_info[track->nb_frag_info - 1];
5459 MOVTrack *track = &mov->tracks[i];
5462 if (!track->entry)
5464 mov_write_traf_tag(pb, mov, track, pos, moof_size);
5471 MOVTrack *track, int ref_size, int total_sidx_size)
5478 if (track->entry) {
5480 presentation_time = track->cluster[0].dts + track->cluster[0].cts -
5481 track->start_dts - track->start_cts;
5482 duration = track->end_pts -
5483 (track->cluster[0].dts + track->cluster[0].cts);
5484 starts_with_SAP = track->cluster[0].flags & MOV_SYNC_SAMPLE;
5492 entries = track->nb_frag_info;
5495 presentation_time = track->frag_info[0].time;
5498 presentation_time -= track->start_dts + track->start_cts;
5505 avio_wb32(pb, track->track_id); /* reference_ID */
5506 avio_wb32(pb, track->timescale); /* timescale */
5514 if (!track->entry) {
5515 if (i > 1 && track->frag_info[i].offset != track->frag_info[i - 1].offset + track->frag_info[i - 1].size) {
5518 duration = track->frag_info[i].duration;
5519 ref_size = track->frag_info[i].size;
5545 // atom, for the first track in the moof.
5553 MOVTrack *track = &mov->tracks[i];
5559 if (!track->entry && ref_size > 0)
5561 total_size -= mov_write_sidx_tag(avio_buf, track, ref_size,
5576 /* PRFT should be associated with at most one track. So, choosing only the
5577 * first track. */
5583 av_log(mov->fc, AV_LOG_WARNING, "Unable to write PRFT, no entries in the track\n");
5614 avio_wb32(pb, first_track->track_id); // reference track ID
5652 static int mov_write_tfra_tag(AVIOContext *pb, MOVTrack *track)
5662 avio_wb32(pb, track->track_id);
5664 avio_wb32(pb, track->nb_frag_info);
5665 for (i = 0; i < track->nb_frag_info; i++) {
5666 avio_wb64(pb, track->frag_info[i].time);
5667 avio_wb64(pb, track->frag_info[i].offset + track->data_offset);
5694 MOVTrack *track = &mov->tracks[i];
5695 if (track->nb_frag_info)
5696 mov_write_tfra_tag(mfra_pb, track);
6068 static int mov_flush_fragment_interleaving(AVFormatContext *s, MOVTrack *track)
6075 if (!track->mdat_buf)
6081 buf_size = avio_get_dyn_buf(track->mdat_buf, &buf);
6085 ffio_free_dyn_buf(&track->mdat_buf);
6087 for (i = track->entries_flushed; i < track->entry; i++)
6088 track->cluster[i].pos += offset;
6089 track->entries_flushed = track->entry;
6093 static int mov_write_squashed_packet(AVFormatContext *s, MOVTrack *track)
6099 switch (track->st->codecpar->codec_id) {
6101 int had_packets = !!track->squashed_packet_queue.head;
6103 if ((ret = ff_mov_generate_squashed_ttml_packet(s, track, squashed_packet)) < 0) {
6113 track->end_reliable = 1;
6121 squashed_packet->stream_index = track->st->index;
6136 MOVTrack *track = &mov->tracks[i];
6139 if (track->squash_fragment_samples_to_one && !track->entry) {
6140 if ((ret = mov_write_squashed_packet(s, track)) < 0) {
6143 "index %d and track id %d. Error: %s\n",
6144 avcodec_get_name(track->st->codecpar->codec_id),
6145 track->st->index, track->track_id,
6174 // already have reliable info for the end of that track, but other
6177 MOVTrack *track = &mov->tracks[i];
6178 if (!track->end_reliable) {
6185 if (track->dts_shift != AV_NOPTS_VALUE)
6186 dts += track->dts_shift;
6187 track->track_duration = dts - track->start_dts;
6189 track->end_pts = pts;
6191 track->end_pts = dts;
6197 MOVTrack *track = &mov->tracks[i];
6198 if (track->entry <= 1)
6206 if (get_cluster_duration(track, track->entry - 1) != 0)
6212 track->track_duration += get_cluster_duration(track, track->entry - 2);
6213 track->end_pts += get_cluster_duration(track, track->entry - 2);
6274 MOVTrack *track = &mov->tracks[i];
6276 if ((ret = mov_flush_fragment_interleaving(s, track)) < 0)
6286 MOVTrack *track = &mov->tracks[i];
6288 track->data_offset = 0;
6290 track->data_offset = mdat_size;
6291 if (track->par->codec_type == AVMEDIA_TYPE_VIDEO) {
6294 if (track->entry)
6295 starts_with_key = track->cluster[0].flags & MOV_SYNC_SAMPLE;
6299 if (!track->entry)
6301 if (track->mdat_buf)
6302 mdat_size += avio_tell(track->mdat_buf);
6315 MOVTrack *track = &mov->tracks[i];
6320 if (!track->entry)
6322 mdat_size = avio_tell(track->mdat_buf);
6338 track->entry = 0;
6339 track->entries_flushed = 0;
6340 track->end_reliable = 0;
6342 if (!track->mdat_buf)
6344 buf_size = avio_close_dyn_buf(track->mdat_buf, &buf);
6345 track->mdat_buf = NULL;
6665 /* Not using edit lists and shifting the first track to start from zero.
6834 // Set the duration of this track to line up with the next
6835 // sample in this track. This avoids relying on AVPacket
6836 // duration, but only helps for this particular track, not
6840 // for this track, and we can't adjust the track end here.
6911 * 1) For full complaince, every track must have a sample at
6914 * at dts == 0 for any subtitle track with no samples in it.
6916 * 2) For each subtitle track, check if the current packet's
6942 * If the track has to have its samples squashed into one sample,
6943 * we just take it into the track's queue.
7007 // QuickTime chapters involve an additional text track with the chapter names
7033 MOVTrack *track = &mov->tracks[tracknum];
7038 track->mode = mov->mode;
7039 track->tag = MKTAG('t','e','x','t');
7040 track->timescale = mov->movie_timescale;
7041 track->par = avcodec_parameters_alloc();
7042 if (!track->par)
7044 track->par->codec_type = AVMEDIA_TYPE_SUBTITLE;
7045 ret = ff_alloc_extradata(track->par, sizeof(stub_header));
7048 memcpy(track->par->extradata, stub_header, sizeof(stub_header));
7099 MOVTrack *track = &mov->tracks[index];
7106 /* tmcd track based on video stream */
7107 track->mode = mov->mode;
7108 track->tag = MKTAG('t','m','c','d');
7109 track->src_track = src_index;
7110 track->timescale = mov->tracks[src_index].timescale;
7112 track->timecode_flags |= MOV_TIMECODE_FLAG_DROPFRAME;
7115 track->st = src_st;
7118 track->par = avcodec_parameters_alloc();
7119 if (!track->par)
7121 track->par->codec_type = AVMEDIA_TYPE_DATA;
7122 track->par->codec_tag = track->tag;
7123 track->st->avg_frame_rate = rate;
7125 /* the tmcd track just contains one packet with the frame number */
7141 MOVTrack *track = &mov->tracks[index];
7147 /* timed metadata track based on video stream */
7148 track->mode = mov->mode;
7149 /* if the timed metadata track describes characteristics of the whole movie,
7150 * there should be no track reference of type 'cdsc'.
7154 track->tag = track_tag;
7155 track->tref_tag = track_tag;
7156 track->src_track = src_index;
7157 track->timescale = mov->tracks[src_index].timescale;
7158 int new_track_count = track->ref_track_count + 1;
7159 ret = av_reallocp_array(&track->tref_ids, new_track_count, sizeof(track->tref_ids));
7162 track->ref_track_count = new_track_count;
7163 track->tref_ids[track->ref_track_count - 1] = src_track->track_id;
7167 track->st = s->streams[index];
7169 track->par = avcodec_parameters_alloc();
7170 if (!track->par)
7172 track->par->codec_type = AVMEDIA_TYPE_TIMEDMETA;
7173 track->par->codec_id = AV_CODEC_ID_FFMETADATA;
7174 track->par->codec_tag = track_tag;
7175 track->st->avg_frame_rate = av_inv_q(rate);
7182 * QuickTime will not play a track if it is not enabled. So make sure
7183 * that one track of each type (audio, video, subtitle) is enabled.
7186 * makes the track "default" (i.e. it is rendered when played). For
7246 MOVTrack *const track = &mov->tracks[i];
7248 if (track->tag == MKTAG('r','t','p',' '))
7249 ff_mov_close_hinting(track);
7250 else if (track->tag == MKTAG('t','m','c','d') && mov->nb_meta_tmcd)
7251 av_freep(&track->par);
7252 av_freep(&track->cluster);
7253 av_freep(&track->frag_info);
7254 av_packet_free(&track->cover_image);
7256 if (track->eac3_priv) {
7257 struct eac3_info *info = track->eac3_priv;
7259 av_freep(&track->eac3_priv);
7261 if (track->vos_len)
7262 av_freep(&track->vos_data);
7264 ff_mov_cenc_free(&track->cenc);
7265 ffio_free_dyn_buf(&track->mdat_buf);
7267 avpriv_packet_list_free(&track->squashed_packet_queue);
7269 av_freep(&track->tref_ids);
7293 static int mov_create_dvd_sub_decoder_specific_info(MOVTrack *track,
7328 track->vos_data = av_malloc(16*4 + AV_INPUT_BUFFER_PADDING_SIZE);
7329 if (!track->vos_data)
7332 AV_WB32(track->vos_data + i * 4, palette[i]);
7334 memset(track->vos_data + 16*4, 0, AV_INPUT_BUFFER_PADDING_SIZE);
7335 track->vos_len = 16 * 4;
7338 st->codecpar->height = track->height = height;
7499 /* +1 tmcd track for each video stream with a timecode */
7512 /* check if there is already a tmcd track to remux */
7517 av_log(s, AV_LOG_WARNING, "You requested a copy of the original timecode track "
7566 MOVTrack *track= &mov->tracks[i];
7569 track->st = st;
7570 track->par = st->codecpar;
7571 track->language = ff_mov_iso639_to_lang(lang?lang->value:"und", mov->mode!=MODE_MOV);
7572 if (track->language < 0)
7573 track->language = 32767; // Unspecified Macintosh language code
7574 track->mode = mov->mode;
7575 track->tag = mov_find_codec_tag(s, track);
7576 if (!track->tag) {
7582 /* If hinting of this track is enabled by a later hint track,
7584 track->hint_track = -1;
7585 track->start_dts = AV_NOPTS_VALUE;
7586 track->start_cts = AV_NOPTS_VALUE;
7587 track->end_pts = AV_NOPTS_VALUE;
7588 track->dts_shift = AV_NOPTS_VALUE;
7590 if (track->tag == MKTAG('m','x','3','p') || track->tag == MKTAG('m','x','3','n') ||
7591 track->tag == MKTAG('m','x','4','p') || track->tag == MKTAG('m','x','4','n') ||
7592 track->tag == MKTAG('m','x','5','p') || track->tag == MKTAG('m','x','5','n')) {
7597 track->height = track->tag >> 24 == 'n' ? 486 : 576;
7600 track->timescale = mov->video_track_timescale;
7604 track->timescale = st->time_base.den;
7605 while(track->timescale < 10000)
7606 track->timescale *= 2;
7612 if (track->mode == MODE_MOV && track->timescale > 100000)
7617 if (track->mode == MODE_MOV &&
7618 track->par->codec_id == AV_CODEC_ID_RAWVIDEO &&
7619 track->tag == MKTAG('r','a','w',' ')) {
7620 enum AVPixelFormat pix_fmt = track->par->format;
7621 if (pix_fmt == AV_PIX_FMT_NONE && track->par->bits_per_coded_sample == 1)
7623 track->is_unaligned_qt_rgb =
7631 if (track->par->codec_id == AV_CODEC_ID_VP9 && track->mode != MODE_MP4) {
7632 av_log(s, AV_LOG_ERROR, "%s only supported in MP4.\n", avcodec_get_name(track->par->codec_id));
7634 } else if (track->par->codec_id == AV_CODEC_ID_AV1 &&
7635 track->mode != MODE_MP4 && track->mode != MODE_AVIF) {
7636 av_log(s, AV_LOG_ERROR, "%s only supported in MP4 and AVIF.\n", avcodec_get_name(track->par->codec_id));
7638 } else if (track->par->codec_id == AV_CODEC_ID_VP8) {
7645 track->cover_image = av_packet_alloc();
7646 if (!track->cover_image)
7650 track->timescale = st->codecpar->sample_rate;
7652 av_log(s, AV_LOG_WARNING, "track %d: codec frame size is not set\n", i);
7653 track->audio_vbr = 1;
7658 av_log(s, AV_LOG_ERROR, "track %d: codec block align is not set for adpcm\n", i);
7661 track->sample_size = st->codecpar->block_align;
7663 track->audio_vbr = 1;
7665 track->sample_size = (av_get_bits_per_sample(st->codecpar->codec_id) >> 3) *
7670 track->audio_vbr = 1;
7672 if (track->mode != MODE_MOV &&
7673 track->par->codec_id == AV_CODEC_ID_MP3 && track->timescale < 16000) {
7675 av_log(s, AV_LOG_ERROR, "track %d: muxing mp3 at %dhz is not standard, to mux anyway set strict to -1\n",
7676 i, track->par->sample_rate);
7679 av_log(s, AV_LOG_WARNING, "track %d: muxing mp3 at %dhz is not standard in MP4\n",
7680 i, track->par->sample_rate);
7683 if (track->par->codec_id == AV_CODEC_ID_FLAC ||
7684 track->par->codec_id == AV_CODEC_ID_TRUEHD ||
7685 track->par->codec_id == AV_CODEC_ID_OPUS) {
7686 if (track->mode != MODE_MP4) {
7687 av_log(s, AV_LOG_ERROR, "%s only supported in MP4.\n", avcodec_get_name(track->par->codec_id));
7690 if (track->par->codec_id != AV_CODEC_ID_OPUS &&
7695 avcodec_get_name(track->par->codec_id), FF_COMPLIANCE_EXPERIMENTAL);
7700 track->timescale = st->time_base.den;
7702 if (track->par->codec_id == AV_CODEC_ID_TTML) {
7704 for TTML, for which we define a per-track flag.
7709 track->squash_fragment_samples_to_one =
7710 ff_is_ttml_stream_paragraph_based(track->par);
7713 track->squash_fragment_samples_to_one) {
7716 "TTML in MP4/ISMV (track synchronization between "
7721 if (track->mode != MODE_ISM &&
7722 track->par->codec_tag == MOV_ISMV_TTML_TAG &&
7732 track->timescale = st->time_base.den;
7735 track->timescale = st->time_base.den;
7738 track->timescale = mov->movie_timescale;
7740 if (!track->height)
7741 track->height = st->codecpar->height;
7743 doesn't mandate a track timescale of 10,000,000. The muxer allows a custom timescale
7748 track->timescale = 10000000;
7751 avpriv_set_pts_info(st, 64, 1, track->timescale);
7754 ret = ff_mov_cenc_init(&track->cenc, mov->encryption_key,
7755 (track->par->codec_id == AV_CODEC_ID_H264 || track->par->codec_id == AV_CODEC_ID_HEVC),
7788 MOVTrack *track= &mov->tracks[i];
7793 mov_create_dvd_sub_decoder_specific_info(track, st);
7794 else if (!TAG_IS_AVCI(track->tag) && st->codecpar->codec_id != AV_CODEC_ID_DNXHD) {
7795 track->vos_len = st->codecpar->extradata_size;
7796 track->vos_data = av_malloc(track->vos_len + AV_INPUT_BUFFER_PADDING_SIZE);
7797 if (!track->vos_data) {
7800 memcpy(track->vos_data, st->codecpar->extradata, track->vos_len);
7801 memset(track->vos_data + track->vos_len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
7806 av_channel_layout_compare(&track->par->ch_layout,
7821 track->mono_as_fc = -1;
7826 trackj->par->ch_layout.nb_channels == 1 && track->mono_as_fc >= 0
7828 track->mono_as_fc++;
7833 trackj->language != track->language ||
7834 trackj->tag != track->tag
7837 track->multichannel_as_mono++;
8039 MOVTrack *track = &mov->tracks[i];
8040 AVCodecParameters *par = track->par;
8042 track->vos_len = par->extradata_size;
8043 av_freep(&track->vos_data);
8044 track->vos_data = av_malloc(track->vos_len + AV_INPUT_BUFFER_PADDING_SIZE);
8045 if (!track->vos_data)
8047 memcpy(track->vos_data, par->extradata, track->vos_len);
8048 memset(track->vos_data + track->vos_len, 0, AV_INPUT_BUFFER_PADDING_SIZE);