29 is_open(false), auto_map_clips(true), managed_cache(true),
path(
""),
75 info.width, info.height, info.fps, info.sample_rate,
76 info.channels, info.channel_layout) {}
80 is_open(false), auto_map_clips(true), managed_cache(true),
path(projectPath),
100 QFileInfo filePath(QString::fromStdString(path));
101 if (!filePath.exists()) {
102 throw InvalidFile(
"File could not be opened.", path);
108 if (!openshotPath.exists()) {
111 QDir openshotTransPath(openshotPath.filePath(
"transitions"));
112 if (!openshotTransPath.exists()) {
113 throw InvalidFile(
"PATH_OPENSHOT_INSTALL/transitions could not be found.", openshotTransPath.path().toStdString());
117 QString asset_name = filePath.baseName().left(30) +
"_assets";
118 QDir asset_folder(filePath.dir().filePath(asset_name));
119 if (!asset_folder.exists()) {
121 asset_folder.mkpath(
".");
125 QFile projectFile(QString::fromStdString(path));
126 projectFile.open(QFile::ReadOnly);
127 QString projectContents = QString::fromUtf8(projectFile.readAll());
130 if (convert_absolute_paths) {
134 QRegularExpression allPathsRegex(QStringLiteral(
"\"(image|path)\":.*?\"(.*?)\""));
135 std::vector<QRegularExpressionMatch> matchedPositions;
136 QRegularExpressionMatchIterator i = allPathsRegex.globalMatch(projectContents);
137 while (i.hasNext()) {
138 QRegularExpressionMatch match = i.next();
139 if (match.hasMatch()) {
141 matchedPositions.push_back(match);
146 std::vector<QRegularExpressionMatch>::reverse_iterator itr;
147 for (itr = matchedPositions.rbegin(); itr != matchedPositions.rend(); itr++) {
148 QRegularExpressionMatch match = *itr;
149 QString relativeKey = match.captured(1);
150 QString relativePath = match.captured(2);
151 QString absolutePath =
"";
154 if (relativePath.startsWith(
"@assets")) {
155 absolutePath = QFileInfo(asset_folder.absoluteFilePath(relativePath.replace(
"@assets",
"."))).canonicalFilePath();
156 }
else if (relativePath.startsWith(
"@transitions")) {
157 absolutePath = QFileInfo(openshotTransPath.absoluteFilePath(relativePath.replace(
"@transitions",
"."))).canonicalFilePath();
159 absolutePath = QFileInfo(filePath.absoluteDir().absoluteFilePath(relativePath)).canonicalFilePath();
163 if (!absolutePath.isEmpty()) {
164 projectContents.replace(match.capturedStart(0), match.capturedLength(0),
"\"" + relativeKey +
"\": \"" + absolutePath +
"\"");
168 matchedPositions.clear();
172 SetJson(projectContents.toStdString());
176 float calculated_duration = 0.0;
177 for (
auto clip : clips)
180 if (clip_last_frame > calculated_duration)
181 calculated_duration = clip_last_frame;
182 if (
clip->Reader() &&
clip->Reader()->info.has_audio)
184 if (
clip->Reader() &&
clip->Reader()->info.has_video)
216 if (managed_cache && final_cache) {
226 auto iterator = tracked_objects.find(trackedObject->Id());
228 if (iterator != tracked_objects.end()){
230 iterator->second = trackedObject;
234 tracked_objects[trackedObject->Id()] = trackedObject;
244 auto iterator = tracked_objects.find(
id);
246 if (iterator != tracked_objects.end()){
248 std::shared_ptr<openshot::TrackedObjectBase> trackedObject = iterator->second;
249 return trackedObject;
261 std::list<std::string> trackedObjects_ids;
264 for (
auto const& it: tracked_objects){
266 trackedObjects_ids.push_back(it.first);
269 return trackedObjects_ids;
277 Json::Value trackedObjectJson;
280 auto iterator = tracked_objects.find(
id);
282 if (iterator != tracked_objects.end())
285 std::shared_ptr<TrackedObjectBBox> trackedObject = std::static_pointer_cast<TrackedObjectBBox>(iterator->second);
288 if (trackedObject->ExactlyContains(frame_number)){
289 BBox box = trackedObject->GetBox(frame_number);
290 float x1 = box.
cx - (box.
width/2);
292 float x2 = box.
cx + (box.
width/2);
294 float rotation = box.
angle;
296 trackedObjectJson[
"x1"] = x1;
297 trackedObjectJson[
"y1"] = y1;
298 trackedObjectJson[
"x2"] = x2;
299 trackedObjectJson[
"y2"] = y2;
300 trackedObjectJson[
"rotation"] = rotation;
303 BBox box = trackedObject->BoxVec.begin()->second;
304 float x1 = box.
cx - (box.
width/2);
306 float x2 = box.
cx + (box.
width/2);
308 float rotation = box.
angle;
310 trackedObjectJson[
"x1"] = x1;
311 trackedObjectJson[
"y1"] = y1;
312 trackedObjectJson[
"x2"] = x2;
313 trackedObjectJson[
"y2"] = y2;
314 trackedObjectJson[
"rotation"] = rotation;
320 trackedObjectJson[
"x1"] = 0;
321 trackedObjectJson[
"y1"] = 0;
322 trackedObjectJson[
"x2"] = 0;
323 trackedObjectJson[
"y2"] = 0;
324 trackedObjectJson[
"rotation"] = 0;
327 return trackedObjectJson.toStyledString();
335 const std::lock_guard<std::recursive_mutex> guard(
getFrameMutex);
341 if (
clip->Reader() &&
clip->Reader()->GetCache())
342 clip->Reader()->GetCache()->Clear();
345 if (auto_map_clips) {
347 apply_mapper_to_clip(
clip);
351 clips.push_back(
clip);
364 effects.push_back(effect);
373 effects.remove(effect);
376 bool allocated = allocated_effects.count(effect);
380 allocated_effects.erase(effect);
391 const std::lock_guard<std::recursive_mutex> guard(
getFrameMutex);
396 bool allocated = allocated_clips.count(
clip);
400 allocated_clips.erase(
clip);
411 for (
const auto&
clip : clips) {
423 for (
const auto& effect : effects) {
424 if (effect->Id() == id) {
434 for (
const auto&
clip : clips) {
435 const auto e =
clip->GetEffect(
id);
447 std::list<EffectBase*> timelineEffectsList;
450 for (
const auto&
clip : clips) {
453 std::list<EffectBase*> clipEffectsList =
clip->Effects();
456 timelineEffectsList.insert(timelineEffectsList.end(), clipEffectsList.begin(), clipEffectsList.end());
459 return timelineEffectsList;
472 return std::round(max_time * fps) + 1;
476void Timeline::apply_mapper_to_clip(
Clip* clip)
480 if (
clip->Reader()->Name() ==
"FrameMapper")
493 allocated_frame_mappers.insert(mapper);
498 clip->Reader(clip_reader);
508 for (
auto clip : clips)
511 apply_mapper_to_clip(
clip);
516double Timeline::calculate_time(int64_t number,
Fraction rate)
519 double raw_fps = rate.
ToFloat();
522 return double(number - 1) / raw_fps;
530 "Timeline::apply_effects",
531 "frame->number", frame->number,
532 "timeline_frame_number", timeline_frame_number,
536 for (
auto effect : effects)
539 long effect_start_position = round(effect->Position() *
info.
fps.
ToDouble()) + 1;
540 long effect_end_position = round((effect->Position() + (effect->Duration())) *
info.
fps.
ToDouble());
542 bool does_effect_intersect = (effect_start_position <= timeline_frame_number && effect_end_position >= timeline_frame_number && effect->Layer() == layer);
546 "Timeline::apply_effects (Does effect intersect)",
547 "effect->Position()", effect->Position(),
548 "does_effect_intersect", does_effect_intersect,
549 "timeline_frame_number", timeline_frame_number,
553 if (does_effect_intersect)
557 long effect_frame_number = timeline_frame_number - effect_start_position + effect_start_frame;
561 "Timeline::apply_effects (Process Effect)",
562 "effect_frame_number", effect_frame_number,
563 "does_effect_intersect", does_effect_intersect);
566 frame = effect->GetFrame(frame, effect_frame_number);
576std::shared_ptr<Frame> Timeline::GetOrCreateFrame(std::shared_ptr<Frame> background_frame,
Clip* clip, int64_t number,
openshot::TimelineInfoStruct* options)
578 std::shared_ptr<Frame> new_frame;
586 "Timeline::GetOrCreateFrame (from reader)",
588 "samples_in_frame", samples_in_frame);
591 new_frame = std::shared_ptr<Frame>(
clip->
GetFrame(background_frame, number, options));
604 "Timeline::GetOrCreateFrame (create blank)",
606 "samples_in_frame", samples_in_frame);
613void Timeline::add_layer(std::shared_ptr<Frame> new_frame,
Clip* source_clip, int64_t clip_frame_number,
bool is_top_clip,
float max_volume)
620 std::shared_ptr<Frame> source_frame;
621 source_frame = GetOrCreateFrame(new_frame, source_clip, clip_frame_number, options);
630 "Timeline::add_layer",
631 "new_frame->number", new_frame->number,
632 "clip_frame_number", clip_frame_number);
635 if (source_clip->
Reader()->info.has_audio) {
638 "Timeline::add_layer (Copy Audio)",
639 "source_clip->Reader()->info.has_audio", source_clip->
Reader()->info.has_audio,
640 "source_frame->GetAudioChannelsCount()", source_frame->GetAudioChannelsCount(),
642 "clip_frame_number", clip_frame_number);
645 for (
int channel = 0; channel < source_frame->GetAudioChannelsCount(); channel++)
648 float previous_volume = source_clip->
volume.
GetValue(clip_frame_number - 1);
656 previous_volume = previous_volume / max_volume;
657 volume = volume / max_volume;
661 previous_volume = previous_volume * 0.77;
662 volume = volume * 0.77;
666 if (channel_filter != -1 && channel_filter != channel)
670 if (previous_volume == 0.0 && volume == 0.0)
674 if (channel_mapping == -1)
675 channel_mapping = channel;
678 if (!isEqual(previous_volume, 1.0) || !isEqual(volume, 1.0))
679 source_frame->ApplyGainRamp(channel_mapping, 0, source_frame->GetAudioSamplesCount(), previous_volume, volume);
685 if (new_frame->GetAudioSamplesCount() != source_frame->GetAudioSamplesCount()){
691 new_frame->AddAudio(
false, channel_mapping, 0, source_frame->GetAudioSamples(channel), source_frame->GetAudioSamplesCount(), 1.0);
696 "Timeline::add_layer (No Audio Copied - Wrong # of Channels)",
697 "source_clip->Reader()->info.has_audio",
698 source_clip->
Reader()->info.has_audio,
699 "source_frame->GetAudioChannelsCount()",
700 source_frame->GetAudioChannelsCount(),
702 "clip_frame_number", clip_frame_number);
707 "Timeline::add_layer (Transform: Composite Image Layer: Completed)",
708 "source_frame->number", source_frame->number,
709 "new_frame->GetImage()->width()", new_frame->GetWidth(),
710 "new_frame->GetImage()->height()", new_frame->GetHeight());
714void Timeline::update_open_clips(
Clip *clip,
bool does_clip_intersect)
717 const std::lock_guard<std::recursive_mutex> guard(
getFrameMutex);
720 "Timeline::update_open_clips (before)",
721 "does_clip_intersect", does_clip_intersect,
722 "closing_clips.size()", closing_clips.size(),
723 "open_clips.size()", open_clips.size());
726 bool clip_found = open_clips.count(
clip);
728 if (clip_found && !does_clip_intersect)
731 open_clips.erase(
clip);
736 else if (!clip_found && does_clip_intersect)
752 "Timeline::update_open_clips (after)",
753 "does_clip_intersect", does_clip_intersect,
754 "clip_found", clip_found,
755 "closing_clips.size()", closing_clips.size(),
756 "open_clips.size()", open_clips.size());
760void Timeline::calculate_max_duration() {
761 double last_clip = 0.0;
762 double last_effect = 0.0;
764 if (!clips.empty()) {
765 const auto max_clip = std::max_element(
767 last_clip = (*max_clip)->Position() + (*max_clip)->Duration();
769 if (!effects.empty()) {
770 const auto max_effect = std::max_element(
772 last_effect = (*max_effect)->Position() + (*max_effect)->Duration();
774 max_time = std::max(last_clip, last_effect);
778void Timeline::sort_clips()
781 const std::lock_guard<std::recursive_mutex> guard(
getFrameMutex);
785 "Timeline::SortClips",
786 "clips.size()", clips.size());
792 calculate_max_duration();
796void Timeline::sort_effects()
799 const std::lock_guard<std::recursive_mutex> guard(
getFrameMutex);
805 calculate_max_duration();
814 const std::lock_guard<std::recursive_mutex> guard(
getFrameMutex);
817 for (
auto clip : clips)
819 update_open_clips(
clip,
false);
822 bool allocated = allocated_clips.count(
clip);
829 allocated_clips.clear();
832 for (
auto effect : effects)
835 bool allocated = allocated_effects.count(effect);
842 allocated_effects.clear();
845 for (
auto mapper : allocated_frame_mappers)
851 allocated_frame_mappers.clear();
860 const std::lock_guard<std::recursive_mutex> guard(
getFrameMutex);
863 for (
auto clip : clips)
866 update_open_clips(
clip,
false);
883bool Timeline::isEqual(
double a,
double b)
885 return fabs(a - b) < 0.000001;
892 if (requested_frame < 1)
896 std::shared_ptr<Frame> frame;
897 frame = final_cache->
GetFrame(requested_frame);
901 "Timeline::GetFrame (Cached frame found)",
902 "requested_frame", requested_frame);
910 const std::lock_guard<std::recursive_mutex> lock(
getFrameMutex);
913 std::shared_ptr<Frame> frame;
914 frame = final_cache->
GetFrame(requested_frame);
918 "Timeline::GetFrame (Cached frame found on 2nd check)",
919 "requested_frame", requested_frame);
926 std::vector<Clip *> nearby_clips;
927 nearby_clips = find_intersecting_clips(requested_frame, 1,
true);
931 "Timeline::GetFrame (processing frame)",
932 "requested_frame", requested_frame,
933 "omp_get_thread_num()", omp_get_thread_num());
940 new_frame->AddAudioSilence(samples_in_frame);
946 "Timeline::GetFrame (Adding solid color)",
947 "requested_frame", requested_frame,
959 "Timeline::GetFrame (Loop through clips)",
960 "requested_frame", requested_frame,
961 "clips.size()", clips.size(),
962 "nearby_clips.size()", nearby_clips.size());
965 for (
auto clip : nearby_clips) {
968 bool does_clip_intersect = (clip_start_position <= requested_frame && clip_end_position >= requested_frame);
972 "Timeline::GetFrame (Does clip intersect)",
973 "requested_frame", requested_frame,
976 "does_clip_intersect", does_clip_intersect);
979 if (does_clip_intersect) {
981 bool is_top_clip =
true;
982 float max_volume = 0.0;
983 for (
auto nearby_clip : nearby_clips) {
984 long nearby_clip_start_position = round(nearby_clip->Position() *
info.
fps.
ToDouble()) + 1;
985 long nearby_clip_end_position = round((nearby_clip->Position() + nearby_clip->Duration()) *
info.
fps.
ToDouble()) + 1;
986 long nearby_clip_start_frame = (nearby_clip->Start() *
info.
fps.
ToDouble()) + 1;
987 long nearby_clip_frame_number = requested_frame - nearby_clip_start_position + nearby_clip_start_frame;
990 if (
clip->
Id() != nearby_clip->Id() &&
clip->
Layer() == nearby_clip->Layer() &&
991 nearby_clip_start_position <= requested_frame && nearby_clip_end_position >= requested_frame &&
992 nearby_clip_start_position > clip_start_position && is_top_clip ==
true) {
997 if (nearby_clip->Reader() && nearby_clip->Reader()->info.has_audio &&
998 nearby_clip->has_audio.GetInt(nearby_clip_frame_number) != 0 &&
999 nearby_clip_start_position <= requested_frame && nearby_clip_end_position >= requested_frame) {
1000 max_volume += nearby_clip->volume.GetValue(nearby_clip_frame_number);
1006 long clip_frame_number = requested_frame - clip_start_position + clip_start_frame;
1010 "Timeline::GetFrame (Calculate clip's frame #)",
1014 "clip_frame_number", clip_frame_number);
1017 add_layer(new_frame,
clip, clip_frame_number, is_top_clip, max_volume);
1022 "Timeline::GetFrame (clip does not intersect)",
1023 "requested_frame", requested_frame,
1024 "does_clip_intersect", does_clip_intersect);
1031 "Timeline::GetFrame (Add frame to cache)",
1032 "requested_frame", requested_frame,
1037 new_frame->SetFrameNumber(requested_frame);
1040 final_cache->
Add(new_frame);
1050std::vector<Clip*> Timeline::find_intersecting_clips(int64_t requested_frame,
int number_of_frames,
bool include)
1053 std::vector<Clip*> matching_clips;
1056 float min_requested_frame = requested_frame;
1057 float max_requested_frame = requested_frame + (number_of_frames - 1);
1060 for (
auto clip : clips)
1066 bool does_clip_intersect =
1067 (clip_start_position <= min_requested_frame || clip_start_position <= max_requested_frame) &&
1068 (clip_end_position >= min_requested_frame || clip_end_position >= max_requested_frame);
1072 "Timeline::find_intersecting_clips (Is clip near or intersecting)",
1073 "requested_frame", requested_frame,
1074 "min_requested_frame", min_requested_frame,
1075 "max_requested_frame", max_requested_frame,
1077 "does_clip_intersect", does_clip_intersect);
1080 update_open_clips(
clip, does_clip_intersect);
1083 if (does_clip_intersect && include)
1085 matching_clips.push_back(
clip);
1087 else if (!does_clip_intersect && !include)
1089 matching_clips.push_back(
clip);
1094 return matching_clips;
1100 const std::lock_guard<std::recursive_mutex> lock(
getFrameMutex);
1103 if (managed_cache && final_cache) {
1106 managed_cache =
false;
1110 final_cache = new_cache;
1125 root[
"type"] =
"Timeline";
1130 root[
"path"] = path;
1133 root[
"clips"] = Json::Value(Json::arrayValue);
1136 for (
const auto existing_clip : clips)
1138 root[
"clips"].append(existing_clip->JsonValue());
1142 root[
"effects"] = Json::Value(Json::arrayValue);
1145 for (
const auto existing_effect: effects)
1147 root[
"effects"].append(existing_effect->JsonValue());
1158 const std::lock_guard<std::recursive_mutex> lock(
getFrameMutex);
1167 catch (
const std::exception& e)
1170 throw InvalidJSON(
"JSON is invalid (missing keys or invalid data types)");
1178 const std::lock_guard<std::recursive_mutex> lock(
getFrameMutex);
1181 bool was_open = is_open;
1188 if (!root[
"path"].isNull())
1189 path = root[
"path"].asString();
1191 if (!root[
"clips"].isNull()) {
1196 for (
const Json::Value existing_clip : root[
"clips"]) {
1201 allocated_clips.insert(c);
1218 if (!root[
"effects"].isNull()) {
1223 for (
const Json::Value existing_effect :root[
"effects"]) {
1227 if (!existing_effect[
"type"].isNull()) {
1229 if ( (e =
EffectInfo().CreateEffect(existing_effect[
"type"].asString())) ) {
1232 allocated_effects.insert(e);
1244 if (!root[
"duration"].isNull()) {
1263 const std::lock_guard<std::recursive_mutex> lock(
getFrameMutex);
1270 for (
const Json::Value change : root) {
1271 std::string change_key = change[
"key"][(uint)0].asString();
1274 if (change_key ==
"clips")
1276 apply_json_to_clips(change);
1278 else if (change_key ==
"effects")
1280 apply_json_to_effects(change);
1284 apply_json_to_timeline(change);
1288 catch (
const std::exception& e)
1291 throw InvalidJSON(
"JSON is invalid (missing keys or invalid data types)");
1296void Timeline::apply_json_to_clips(Json::Value change) {
1299 std::string change_type = change[
"type"].asString();
1300 std::string clip_id =
"";
1301 Clip *existing_clip = NULL;
1304 for (
auto key_part : change[
"key"]) {
1306 if (key_part.isObject()) {
1308 if (!key_part[
"id"].isNull()) {
1310 clip_id = key_part[
"id"].asString();
1313 for (
auto c : clips)
1315 if (c->Id() == clip_id) {
1327 if (existing_clip && change[
"key"].size() == 4 && change[
"key"][2] ==
"effects")
1330 Json::Value key_part = change[
"key"][3];
1332 if (key_part.isObject()) {
1334 if (!key_part[
"id"].isNull())
1337 std::string effect_id = key_part[
"id"].asString();
1340 std::list<EffectBase*> effect_list = existing_clip->
Effects();
1341 for (
auto e : effect_list)
1343 if (e->Id() == effect_id) {
1345 apply_json_to_effects(change, e);
1350 final_cache->
Remove(new_starting_frame - 8, new_ending_frame + 8);
1360 if (!change[
"value"].isArray() && !change[
"value"][
"position"].isNull()) {
1361 int64_t new_starting_frame = (change[
"value"][
"position"].asDouble() *
info.
fps.
ToDouble()) + 1;
1362 int64_t new_ending_frame = ((change[
"value"][
"position"].asDouble() + change[
"value"][
"end"].asDouble() - change[
"value"][
"start"].asDouble()) *
info.
fps.
ToDouble()) + 1;
1363 final_cache->
Remove(new_starting_frame - 8, new_ending_frame + 8);
1367 if (change_type ==
"insert") {
1373 allocated_clips.insert(
clip);
1381 }
else if (change_type ==
"update") {
1384 if (existing_clip) {
1389 final_cache->
Remove(old_starting_frame - 8, old_ending_frame + 8);
1392 if (existing_clip->
Reader() && existing_clip->
Reader()->GetCache())
1393 existing_clip->
Reader()->GetCache()->Remove(old_starting_frame - 8, old_ending_frame + 8);
1399 if (auto_map_clips) {
1400 apply_mapper_to_clip(existing_clip);
1404 }
else if (change_type ==
"delete") {
1407 if (existing_clip) {
1412 final_cache->
Remove(old_starting_frame - 8, old_ending_frame + 8);
1425void Timeline::apply_json_to_effects(Json::Value change) {
1428 std::string change_type = change[
"type"].asString();
1432 for (
auto key_part : change[
"key"]) {
1434 if (key_part.isObject()) {
1436 if (!key_part[
"id"].isNull())
1439 std::string effect_id = key_part[
"id"].asString();
1442 for (
auto e : effects)
1444 if (e->Id() == effect_id) {
1445 existing_effect = e;
1455 if (existing_effect || change_type ==
"insert") {
1457 apply_json_to_effects(change, existing_effect);
1462void Timeline::apply_json_to_effects(Json::Value change,
EffectBase* existing_effect) {
1465 std::string change_type = change[
"type"].asString();
1468 if (!change[
"value"].isArray() && !change[
"value"][
"position"].isNull()) {
1469 int64_t new_starting_frame = (change[
"value"][
"position"].asDouble() *
info.
fps.
ToDouble()) + 1;
1470 int64_t new_ending_frame = ((change[
"value"][
"position"].asDouble() + change[
"value"][
"end"].asDouble() - change[
"value"][
"start"].asDouble()) *
info.
fps.
ToDouble()) + 1;
1471 final_cache->
Remove(new_starting_frame - 8, new_ending_frame + 8);
1475 if (change_type ==
"insert") {
1478 std::string effect_type = change[
"value"][
"type"].asString();
1487 allocated_effects.insert(e);
1496 }
else if (change_type ==
"update") {
1499 if (existing_effect) {
1504 final_cache->
Remove(old_starting_frame - 8, old_ending_frame + 8);
1510 }
else if (change_type ==
"delete") {
1513 if (existing_effect) {
1518 final_cache->
Remove(old_starting_frame - 8, old_ending_frame + 8);
1531void Timeline::apply_json_to_timeline(Json::Value change) {
1532 bool cache_dirty =
true;
1535 std::string change_type = change[
"type"].asString();
1536 std::string root_key = change[
"key"][(uint)0].asString();
1537 std::string sub_key =
"";
1538 if (change[
"key"].size() >= 2)
1539 sub_key = change[
"key"][(uint)1].asString();
1542 if (change_type ==
"insert" || change_type ==
"update") {
1546 if (root_key ==
"color")
1549 else if (root_key ==
"viewport_scale")
1552 else if (root_key ==
"viewport_x")
1555 else if (root_key ==
"viewport_y")
1558 else if (root_key ==
"duration") {
1564 cache_dirty =
false;
1566 else if (root_key ==
"width") {
1571 else if (root_key ==
"height") {
1576 else if (root_key ==
"fps" && sub_key ==
"" && change[
"value"].isObject()) {
1578 if (!change[
"value"][
"num"].isNull())
1579 info.
fps.
num = change[
"value"][
"num"].asInt();
1580 if (!change[
"value"][
"den"].isNull())
1581 info.
fps.
den = change[
"value"][
"den"].asInt();
1583 else if (root_key ==
"fps" && sub_key ==
"num")
1586 else if (root_key ==
"fps" && sub_key ==
"den")
1589 else if (root_key ==
"display_ratio" && sub_key ==
"" && change[
"value"].isObject()) {
1591 if (!change[
"value"][
"num"].isNull())
1593 if (!change[
"value"][
"den"].isNull())
1596 else if (root_key ==
"display_ratio" && sub_key ==
"num")
1599 else if (root_key ==
"display_ratio" && sub_key ==
"den")
1602 else if (root_key ==
"pixel_ratio" && sub_key ==
"" && change[
"value"].isObject()) {
1604 if (!change[
"value"][
"num"].isNull())
1606 if (!change[
"value"][
"den"].isNull())
1609 else if (root_key ==
"pixel_ratio" && sub_key ==
"num")
1612 else if (root_key ==
"pixel_ratio" && sub_key ==
"den")
1616 else if (root_key ==
"sample_rate")
1619 else if (root_key ==
"channels")
1622 else if (root_key ==
"channel_layout")
1627 throw InvalidJSONKey(
"JSON change key is invalid", change.toStyledString());
1630 }
else if (change[
"type"].asString() ==
"delete") {
1634 if (root_key ==
"color") {
1640 else if (root_key ==
"viewport_scale")
1642 else if (root_key ==
"viewport_x")
1644 else if (root_key ==
"viewport_y")
1648 throw InvalidJSONKey(
"JSON change key is invalid", change.toStyledString());
1663 final_cache->
Clear();
1668 for (
const auto clip : clips) {
1670 clip->Reader()->GetCache()->Clear();
1673 if (deep &&
clip->Reader()->Name() ==
"FrameMapper") {
1680 clip->GetCache()->Clear();
1695 display_ratio_size.scale(proposed_size, Qt::KeepAspectRatio);
Header file for CacheBase class.
Header file for CacheDisk class.
Header file for CacheMemory class.
Header file for CrashHandler class.
Header file for all Exception classes.
Header file for the FrameMapper class.
#define OPEN_MP_NUM_PROCESSORS
Header file for Timeline class.
All cache managers in libopenshot are based on this CacheBase class.
virtual void Clear()=0
Clear the cache of all frames.
virtual void Remove(int64_t frame_number)=0
Remove a specific frame.
virtual std::shared_ptr< openshot::Frame > GetFrame(int64_t frame_number)=0
Get a frame from the cache.
virtual void Add(std::shared_ptr< openshot::Frame > frame)=0
Add a Frame to the cache.
void SetMaxBytesFromInfo(int64_t number_of_frames, int width, int height, int sample_rate, int channels)
Set maximum bytes to a different amount based on a ReaderInfo struct.
This class is a memory-based cache manager for Frame objects.
float Start() const
Get start position (in seconds) of clip (trim start of video)
float Duration() const
Get the length of this clip (in seconds)
virtual std::shared_ptr< openshot::Frame > GetFrame(int64_t frame_number)=0
This method is required for all derived classes of ClipBase, and returns a new openshot::Frame object...
std::string Id() const
Get the Id of this clip object.
int Layer() const
Get layer of clip on timeline (lower number is covered by higher numbers)
virtual void SetJsonValue(const Json::Value root)=0
Load Json::Value into this object.
float Position() const
Get position on timeline (in seconds)
virtual openshot::TimelineBase * ParentTimeline()
Get the associated Timeline pointer (if any)
This class represents a clip (used to arrange readers on the timeline)
openshot::VolumeMixType mixing
What strategy should be followed when mixing audio with other clips.
openshot::Keyframe channel_filter
A number representing an audio channel to filter (clears all other channels)
void SetJsonValue(const Json::Value root) override
Load Json::Value into this object.
openshot::Keyframe has_audio
An optional override to determine if this clip has audio (-1=undefined, 0=no, 1=yes)
openshot::TimelineBase * ParentTimeline() override
Get the associated Timeline pointer (if any)
std::list< openshot::EffectBase * > Effects()
Return the list of effects on the timeline.
openshot::Keyframe volume
Curve representing the volume (0 to 1)
openshot::Keyframe channel_mapping
A number representing an audio channel to output (only works when filtering a channel)
void Reader(openshot::ReaderBase *new_reader)
Set the current reader.
This class represents a color (used on the timeline and clips)
std::string GetColorHex(int64_t frame_number)
Get the HEX value of a color at a specific frame.
openshot::Keyframe blue
Curve representing the red value (0 - 255)
openshot::Keyframe red
Curve representing the red value (0 - 255)
openshot::Keyframe green
Curve representing the green value (0 - 255)
void SetJsonValue(const Json::Value root)
Load Json::Value into this object.
Json::Value JsonValue() const
Generate Json::Value for this object.
static CrashHandler * Instance()
This abstract class is the base class, used by all effects in libopenshot.
virtual void SetJsonValue(const Json::Value root)
Load Json::Value into this object.
This class returns a listing of all effects supported by libopenshot.
EffectBase * CreateEffect(std::string effect_type)
Create an instance of an effect (factory style)
This class represents a fraction.
int num
Numerator for the fraction.
float ToFloat()
Return this fraction as a float (i.e. 1/2 = 0.5)
double ToDouble() const
Return this fraction as a double (i.e. 1/2 = 0.5)
void Reduce()
Reduce this fraction (i.e. 640/480 = 4/3)
Fraction Reciprocal() const
Return the reciprocal as a Fraction.
int den
Denominator for the fraction.
This class creates a mapping between 2 different frame rates, applying a specific pull-down technique...
void ChangeMapping(Fraction target_fps, PulldownType pulldown, int target_sample_rate, int target_channels, ChannelLayout target_channel_layout)
Change frame rate or audio mapping details.
ReaderBase * Reader()
Get the current reader.
void Close() override
Close the openshot::FrameMapper and internal reader.
int GetSamplesPerFrame(openshot::Fraction fps, int sample_rate, int channels)
Calculate the # of samples per video frame (for the current frame number)
Exception for files that can not be found or opened.
Exception for missing JSON Change key.
Exception for invalid JSON.
A Keyframe is a collection of Point instances, which is used to vary a number or property over time.
int GetInt(int64_t index) const
Get the rounded INT value at a specific index.
void SetJsonValue(const Json::Value root)
Load Json::Value into this object.
double GetValue(int64_t index) const
Get the value at a specific index.
Json::Value JsonValue() const
Generate Json::Value for this object.
int64_t GetCount() const
Get the number of points (i.e. # of points)
Exception for frames that are out of bounds.
This abstract class is the base class, used by all readers in libopenshot.
openshot::ReaderInfo info
Information about the current media file.
virtual void SetJsonValue(const Json::Value root)=0
Load Json::Value into this object.
virtual Json::Value JsonValue() const =0
Generate Json::Value for this object.
std::recursive_mutex getFrameMutex
Mutex for multiple threads.
virtual openshot::CacheBase * GetCache()=0
Get the cache object used by this reader (note: not all readers use cache)
openshot::ClipBase * clip
Pointer to the parent clip instance (if any)
Exception when a reader is closed, and a frame is requested.
This class is contains settings used by libopenshot (and can be safely toggled at any point)
std::string PATH_OPENSHOT_INSTALL
static Settings * Instance()
Create or get an instance of this logger singleton (invoke the class with this method)
int preview_height
Optional preview width of timeline image. If your preview window is smaller than the timeline,...
int preview_width
Optional preview width of timeline image. If your preview window is smaller than the timeline,...
This class represents a timeline.
void AddTrackedObject(std::shared_ptr< openshot::TrackedObjectBase > trackedObject)
Add to the tracked_objects map a pointer to a tracked object (TrackedObjectBBox)
Json::Value JsonValue() const override
Generate Json::Value for this object.
openshot::Keyframe viewport_scale
Curve representing the scale of the viewport (0 to 100)
void ApplyJsonDiff(std::string value)
Apply a special formatted JSON object, which represents a change to the timeline (add,...
openshot::EffectBase * GetClipEffect(const std::string &id)
Look up a clip effect by ID.
void AddClip(openshot::Clip *clip)
Add an openshot::Clip to the timeline.
std::list< openshot::EffectBase * > ClipEffects() const
Return the list of effects on all clips.
std::list< std::string > GetTrackedObjectsIds() const
Return the ID's of the tracked objects as a list of strings.
std::string Json() const override
Generate JSON string of this object.
int64_t GetMaxFrame()
Look up the end frame number of the latest element on the timeline.
std::shared_ptr< openshot::Frame > GetFrame(int64_t requested_frame) override
void ApplyMapperToClips()
Apply the timeline's framerate and samplerate to all clips.
openshot::Color color
Background color of timeline canvas.
std::string GetTrackedObjectValues(std::string id, int64_t frame_number) const
Return the trackedObject's properties as a JSON string.
Timeline(int width, int height, openshot::Fraction fps, int sample_rate, int channels, openshot::ChannelLayout channel_layout)
Constructor for the timeline (which configures the default frame properties)
std::shared_ptr< openshot::TrackedObjectBase > GetTrackedObject(std::string id) const
Return tracked object pointer by it's id.
openshot::EffectBase * GetEffect(const std::string &id)
Look up a timeline effect by ID.
void SetJsonValue(const Json::Value root) override
Load Json::Value into this object.
openshot::Clip * GetClip(const std::string &id)
Look up a single clip by ID.
void ClearAllCache(bool deep=false)
void AddEffect(openshot::EffectBase *effect)
Add an effect to the timeline.
std::shared_ptr< openshot::Frame > apply_effects(std::shared_ptr< openshot::Frame > frame, int64_t timeline_frame_number, int layer)
Apply global/timeline effects to the source frame (if any)
void SetCache(openshot::CacheBase *new_cache)
void Clear()
Clear all clips, effects, and frame mappers from timeline (and free memory)
openshot::Keyframe viewport_x
Curve representing the x coordinate for the viewport.
void RemoveClip(openshot::Clip *clip)
Remove an openshot::Clip from the timeline.
void SetMaxSize(int width, int height)
double GetMaxTime()
Look up the end time of the latest timeline element.
void RemoveEffect(openshot::EffectBase *effect)
Remove an effect from the timeline.
void Open() override
Open the reader (and start consuming resources)
void SetJson(const std::string value) override
Load JSON string into this object.
openshot::Keyframe viewport_y
Curve representing the y coordinate for the viewport.
void Close() override
Close the timeline reader (and any resources it was consuming)
void AppendDebugMethod(std::string method_name, std::string arg1_name="", float arg1_value=-1.0, std::string arg2_name="", float arg2_value=-1.0, std::string arg3_name="", float arg3_value=-1.0, std::string arg4_name="", float arg4_value=-1.0, std::string arg5_name="", float arg5_value=-1.0, std::string arg6_name="", float arg6_value=-1.0)
Append debug information.
static ZmqLogger * Instance()
Create or get an instance of this logger singleton (invoke the class with this method)
This namespace is the default namespace for all code in the openshot library.
@ PULLDOWN_NONE
Do not apply pull-down techniques, just repeat or skip entire frames.
ChannelLayout
This enumeration determines the audio channel layout (such as stereo, mono, 5 point surround,...
@ VOLUME_MIX_AVERAGE
Evenly divide the overlapping clips volume keyframes, so that the sum does not exceed 100%.
@ VOLUME_MIX_REDUCE
Reduce volume by about %25, and then mix (louder, but could cause pops if the sum exceeds 100%)
const Json::Value stringToJson(const std::string value)
This struct holds the information of a bounding-box.
float cy
y-coordinate of the bounding box center
float height
bounding box height
float cx
x-coordinate of the bounding box center
float width
bounding box width
float angle
bounding box rotation angle [degrees]
Like CompareClipEndFrames, but for effects.
This struct contains info about a media file, such as height, width, frames per second,...
float duration
Length of time (in seconds)
int width
The width of the video (in pixesl)
int channels
The number of audio channels used in the audio stream.
openshot::Fraction fps
Frames per second, as a fraction (i.e. 24/1 = 24 fps)
openshot::Fraction display_ratio
The ratio of width to height of the video stream (i.e. 640x480 has a ratio of 4/3)
int height
The height of the video (in pixels)
int64_t video_length
The number of frames in the video stream.
std::string acodec
The name of the audio codec used to encode / decode the video stream.
std::string vcodec
The name of the video codec used to encode / decode the video stream.
openshot::Fraction pixel_ratio
The pixel ratio of the video stream as a fraction (i.e. some pixels are not square)
openshot::ChannelLayout channel_layout
The channel layout (mono, stereo, 5 point surround, etc...)
bool has_video
Determines if this file has a video stream.
bool has_audio
Determines if this file has an audio stream.
openshot::Fraction video_timebase
The video timebase determines how long each frame stays on the screen.
int sample_rate
The number of audio samples per second (44100 is a common sample rate)
This struct contains info about the current Timeline clip instance.
bool is_top_clip
Is clip on top (if overlapping another clip)