griefith/test2
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

IMB: Cleanup timecode options

Browse Source 
Remove options that are duplicate and change description of options, so
they describe bit better, how timecodes are actually used.

Timecodes in Blender have pretty much nothing in common with more widely
known term "timecode". This confused users (and developers).
There were 5 options of which 3 were exactly same. This commit leaves
user with 3 options:
 - Use timecodes for normal seeking/playback - Record Run
 - Ensure, that no frame is duplicated or skipped - "Record Run No Gaps"
 - Do not use timecodes - "None"

More verbose description was added to the definition in code.

Naming of these timecode types was kept, even if it is incorrect to not
break scripts and habits.

Pull Request: https://projects.blender.org/blender/blender/pulls/121001
This commit is contained in:
Richard Antalik
2024-05-06 17:56:56 +02:00
committed by Richard Antalik
parent 89c1f7e0c3
commit 69472c88ee
11 changed files with 104 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
source/blender/blenkernel/BKE_blender_version.h
View File

@@ -29,7 +29,7 @@ extern "C" {
/* Blender file format version. */
#define BLENDER_FILE_VERSION BLENDER_VERSION
#define BLENDER_FILE_SUBVERSION 27
#define BLENDER_FILE_SUBVERSION 28
/* Minimum Blender version that supports reading file written with the current
* version. Older Blender versions will test this and cancel loading the file, showing a warning to

3
source/blender/blenloader/intern/versioning_260.cc
View File

@@ -1255,8 +1255,7 @@ void blo_do_versions_260(FileData *fd, Library * /*lib*/, Main *bmain)
clip->aspy = 1.0f;
}
clip->proxy.build_tc_flag = IMB_TC_RECORD_RUN | IMB_TC_FREE_RUN |
IMB_TC_INTERPOLATED_REC_DATE_FREE_RUN;
clip->proxy.build_tc_flag = IMB_TC_RECORD_RUN;
if (clip->proxy.build_size_flag == 0) {
clip->proxy.build_size_flag = IMB_PROXY_25;

33
source/blender/blenloader/intern/versioning_400.cc
View File

@@ -62,6 +62,8 @@
#include "BKE_scene.hh"
#include "BKE_tracking.h"
#include "IMB_imbuf_enums.h"
#include "SEQ_iterator.hh"
#include "SEQ_sequencer.hh"
@@ -2077,6 +2079,24 @@ static bool seq_hue_correct_set_wrapping(Sequence *seq, void * /*user_data*/)
return true;
}
static void versioning_update_timecode(short int *tc)
{
/* 2 = IMB_TC_FREE_RUN, 4 = IMB_TC_INTERPOLATED_REC_DATE_FREE_RUN. */
if (ELEM(*tc, 2, 4)) {
*tc = IMB_TC_RECORD_RUN;
}
}
static bool seq_proxies_timecode_update(Sequence *seq, void * /*user_data*/)
{
if (seq->strip == nullptr || seq->strip->proxy == nullptr) {
return true;
}
StripProxy *proxy = seq->strip->proxy;
versioning_update_timecode(&proxy->tc);
return true;
}
static void versioning_node_hue_correct_set_wrappng(bNodeTree *ntree)
{
if (ntree->type == NTREE_COMPOSIT) {
@@ -3347,6 +3367,19 @@ void blo_do_versions_400(FileData *fd, Library * /*lib*/, Main *bmain)
}
}
if (!MAIN_VERSION_FILE_ATLEAST(bmain, 402, 28)) {
LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
if (scene->ed != nullptr) {
SEQ_for_each_callback(&scene->ed->seqbase, seq_proxies_timecode_update, nullptr);
}
}
LISTBASE_FOREACH (MovieClip *, clip, &bmain->movieclips) {
MovieClipProxy proxy = clip->proxy;
versioning_update_timecode(&proxy.tc);
}
}
/**
* Always bump subversion in BKE_blender_version.h when adding versioning
* code here, and wrap it inside a MAIN_VERSION_FILE_ATLEAST check.

32
source/blender/imbuf/IMB_imbuf_enums.h
View File

@@ -45,28 +45,32 @@ enum eImbFileType {
#endif
};
/**
* Timecode files contain timestamps (PTS, DTS) and packet seek position. These values are obtained
* by decoding each frame in movie stream. Timecode types define how these map to frame index in
* Blender. This is used when seeking in movie stream.
* Note, that meaning of terms timecode and record run here has little connection to their actual
* meaning.
*/
typedef enum IMB_Timecode_Type {
/** Don't use time-code files at all. */
/** Don't use time-code files at all. Use FFmpeg API to seek to PTS calculated on the fly. */
IMB_TC_NONE = 0,
/**
* Use images in the order as they are recorded
* (currently, this is the only one implemented
* and is a sane default).
* TC entries (and therefore frames in movie stream) are mapped to frame index, such that
* timestamp in Blender matches timestamp in the movie stream. This assumes, that time starts at
* 0 in both cases.
*
* Simplified formula is `frame_index = movie_stream_timestamp * FPS`.
*/
IMB_TC_RECORD_RUN = 1,
/**
* Use global timestamp written by recording
* device (prosumer camcorders e.g. can do that).
* Each TC entry (and therefore frame in movie stream) is mapped to new frame index in Blender.
*
* For example: FFmpeg may say, that a frame should be displayed for 0.5 seconds, but this option
* ignores that and only diplays it in one particular frame index in Blender.
*/
IMB_TC_FREE_RUN = 2,
/**
* Interpolate a global timestamp using the
* record date and time written by recording
* device (*every* consumer camcorder can do that).
*/
IMB_TC_INTERPOLATED_REC_DATE_FREE_RUN = 4,
IMB_TC_RECORD_RUN_NO_GAPS = 8,
IMB_TC_MAX_SLOT = 4,
IMB_TC_NUM_TYPES = 2,
} IMB_Timecode_Type;
typedef enum IMB_Proxy_Size {

3
source/blender/imbuf/intern/IMB_anim.hh
View File

@@ -67,7 +67,8 @@ struct ImBufAnim {
int indices_tried;
ImBufAnim *proxy_anim[IMB_PROXY_MAX_SLOT];
ImBufAnimIndex *curr_idx[IMB_TC_MAX_SLOT];
ImBufAnimIndex *record_run;
ImBufAnimIndex *no_gaps;
char colorspace[64];
char suffix[64]; /* MAX_NAME - multiview */

63
source/blender/imbuf/intern/indexer.cc
View File

@@ -10,6 +10,7 @@
#include "MEM_guardedalloc.h"
#include "BLI_array.hh"
#include "BLI_endian_defines.h"
#include "BLI_endian_switch.h"
#include "BLI_fileops.h"
@@ -21,6 +22,7 @@
#include "BLI_threads.h"
#include "BLI_time.h"
#include "BLI_utildefines.h"
#ifdef _WIN32
# include "BLI_winstuff.h"
#endif
@@ -44,15 +46,6 @@ static const IMB_Proxy_Size proxy_sizes[] = {
IMB_PROXY_25, IMB_PROXY_50, IMB_PROXY_75, IMB_PROXY_100};
static const float proxy_fac[] = {0.25, 0.50, 0.75, 1.00};
#ifdef WITH_FFMPEG
static IMB_Timecode_Type tc_types[] = {
IMB_TC_RECORD_RUN,
IMB_TC_FREE_RUN,
IMB_TC_INTERPOLATED_REC_DATE_FREE_RUN,
IMB_TC_RECORD_RUN_NO_GAPS,
};
#endif
#define INDEX_FILE_VERSION 2
/* ----------------------------------------------------------------------
@@ -358,12 +351,8 @@ int IMB_timecode_to_array_index(IMB_Timecode_Type tc)
return -1;
case IMB_TC_RECORD_RUN:
return 0;
case IMB_TC_FREE_RUN:
return 1;
case IMB_TC_INTERPOLATED_REC_DATE_FREE_RUN:
return 2;
case IMB_TC_RECORD_RUN_NO_GAPS:
return 3;
return 1;
default:
BLI_assert_msg(0, "Unhandled timecode type enum!");
return -1;
@@ -433,8 +422,6 @@ static void get_tc_filepath(ImBufAnim *anim, IMB_Timecode_Type tc, char *filepat
const char *index_names[] = {
"record_run%s%s.blen_tc",
"free_run%s%s.blen_tc",
"interp_free_run%s%s.blen_tc",
"record_run_no_gaps%s%s.blen_tc",
};
@@ -785,6 +772,8 @@ static void free_proxy_output_ffmpeg(proxy_output_ctx *ctx, int rollback)
MEM_freeN(ctx);
}
static blender::Array<IMB_Timecode_Type> tc_types{IMB_TC_RECORD_RUN, IMB_TC_RECORD_RUN_NO_GAPS};
struct FFmpegIndexBuilderContext : public IndexBuildContext {
AVFormatContext *iFormatCtx;
@@ -794,10 +783,9 @@ struct FFmpegIndexBuilderContext : public IndexBuildContext {
int videoStream;
int num_proxy_sizes;
int num_indexers;
proxy_output_ctx *proxy_ctx[IMB_PROXY_MAX_SLOT];
anim_index_builder *indexer[IMB_TC_MAX_SLOT];
anim_index_builder *indexer[IMB_TC_NUM_TYPES];
int tcs_in_use;
int proxy_sizes_in_use;
@@ -827,13 +815,11 @@ static IndexBuildContext *index_ffmpeg_create_context(ImBufAnim *anim,
FFmpegIndexBuilderContext *context = MEM_cnew<FFmpegIndexBuilderContext>(
"FFmpeg index builder context");
int num_proxy_sizes = IMB_PROXY_MAX_SLOT;
int num_indexers = IMB_TC_MAX_SLOT;
int i, streamcount;
context->tcs_in_use = tcs_in_use;
context->proxy_sizes_in_use = proxy_sizes_in_use;
context->num_proxy_sizes = IMB_PROXY_MAX_SLOT;
context->num_indexers = IMB_TC_MAX_SLOT;
context->build_only_on_bad_performance = build_only_on_bad_performance;
memset(context->proxy_ctx, 0, sizeof(context->proxy_ctx));
@@ -929,7 +915,7 @@ static IndexBuildContext *index_ffmpeg_create_context(ImBufAnim *anim,
return nullptr; /* Nothing to transcode. */
}
for (i = 0; i < num_indexers; i++) {
for (i = 0; i < tc_types.size(); i++) {
if (tcs_in_use & tc_types[i]) {
char filepath[FILE_MAX];
@@ -951,7 +937,7 @@ static void index_rebuild_ffmpeg_finish(FFmpegIndexBuilderContext *context, cons
const bool do_rollback = stop || context->building_cancelled;
for (i = 0; i < context->num_indexers; i++) {
for (i = 0; i < tc_types.size(); i++) {
if (context->tcs_in_use & tc_types[i]) {
IMB_index_builder_finish(context->indexer[i], do_rollback);
}
@@ -1003,7 +989,7 @@ static void index_rebuild_ffmpeg_proc_decoded_frame(FFmpegIndexBuilderContext *c
s_dts = context->last_seek_pos_dts;
}
for (i = 0; i < context->num_indexers; i++) {
for (i = 0; i < tc_types.size(); i++) {
if (context->tcs_in_use & tc_types[i]) {
int tc_frameno = context->frameno;
@@ -1349,11 +1335,13 @@ void IMB_free_indices(ImBufAnim *anim)
}
}
for (i = 0; i < IMB_TC_MAX_SLOT; i++) {
if (anim->curr_idx[i]) {
IMB_indexer_close(anim->curr_idx[i]);
anim->curr_idx[i] = nullptr;
}
if (anim->record_run) {
IMB_indexer_close(anim->record_run);
anim->record_run = nullptr;
}
if (anim->no_gaps) {
IMB_indexer_close(anim->no_gaps);
anim->no_gaps = nullptr;
}
anim->proxies_tried = 0;
@@ -1400,27 +1388,30 @@ ImBufAnim *IMB_anim_open_proxy(ImBufAnim *anim, IMB_Proxy_Size preview_size)
ImBufAnimIndex *IMB_anim_open_index(ImBufAnim *anim, IMB_Timecode_Type tc)
{
char filepath[FILE_MAX];
int i = IMB_timecode_to_array_index(tc);
if (i < 0) {
return nullptr;
ImBufAnimIndex **index = nullptr;
if (tc == IMB_TC_RECORD_RUN) {
index = &anim->record_run;
}
if (anim->curr_idx[i]) {
return anim->curr_idx[i];
else if (tc == IMB_TC_RECORD_RUN_NO_GAPS) {
index = &anim->no_gaps;
}
if (anim->indices_tried & tc) {
return nullptr;
}
if (index == nullptr) {
return nullptr;
}
get_tc_filepath(anim, tc, filepath);
anim->curr_idx[i] = IMB_indexer_open(filepath);
*index = IMB_indexer_open(filepath);
anim->indices_tried |= tc;
return anim->curr_idx[i];
return *index;
}
int IMB_anim_index_get_frame_index(ImBufAnim *anim, IMB_Timecode_Type tc, int position)

3
source/blender/makesdna/DNA_movieclip_defaults.h
View File

@@ -17,8 +17,7 @@
#define _DNA_DEFAULT_MovieClipProxy \
{ \
.build_size_flag = IMB_PROXY_25, \
.build_tc_flag = IMB_TC_RECORD_RUN | IMB_TC_FREE_RUN | \
IMB_TC_INTERPOLATED_REC_DATE_FREE_RUN | IMB_TC_RECORD_RUN_NO_GAPS, \
.build_tc_flag = IMB_TC_RECORD_RUN | IMB_TC_RECORD_RUN_NO_GAPS, \
.quality = 50, \
}

5
source/blender/makesdna/DNA_sequence_types.h
View File

@@ -675,10 +675,7 @@ enum {
enum {
SEQ_PROXY_TC_NONE = 0,
SEQ_PROXY_TC_RECORD_RUN = 1 << 0,
SEQ_PROXY_TC_FREE_RUN = 1 << 1,
SEQ_PROXY_TC_INTERP_REC_DATE_FREE_RUN = 1 << 2,
SEQ_PROXY_TC_RECORD_RUN_NO_GAPS = 1 << 3,
SEQ_PROXY_TC_ALL = (1 << 4) - 1,
SEQ_PROXY_TC_RECORD_RUN_NO_GAPS = 1 << 1,
};
/** SeqProxy.build_flags */

37
source/blender/makesrna/intern/rna_movieclip.cc
View File

@@ -143,28 +143,23 @@ static void rna_def_movieclip_proxy(BlenderRNA *brna)
PropertyRNA *prop;
static const EnumPropertyItem clip_tc_items[] = {
{IMB_TC_NONE, "NONE", 0, "None", ""},
{IMB_TC_NONE,
"NONE",
0,
"None",
"Ignore generated timecodes, seek in movie stream based on calculated timestamp"},
{IMB_TC_RECORD_RUN,
"RECORD_RUN",
0,
"Record Run",
"Use images in the order they are recorded"},
{IMB_TC_FREE_RUN,
"FREE_RUN",
0,
"Free Run",
"Use global timestamp written by recording device"},
{IMB_TC_INTERPOLATED_REC_DATE_FREE_RUN,
"FREE_RUN_REC_DATE",
0,
"Free Run (rec date)",
"Interpolate a global timestamp using the record date and time "
"written by recording device"},
"Seek based on timestamps read from movie stream, giving the best match between scene and "
"movie times"},
{IMB_TC_RECORD_RUN_NO_GAPS,
"FREE_RUN_NO_GAPS",
0,
"Free Run No Gaps",
"Record run, but ignore timecode, changes in framerate or dropouts"},
"Record Run No Gaps",
"Effectively convert movie to an image sequence, ignoring incomplete or dropped frames, "
"and changes in frame rate"},
{0, nullptr, 0, nullptr, nullptr},
};
@@ -228,18 +223,6 @@ static void rna_def_movieclip_proxy(BlenderRNA *brna)
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_ui_text(prop, "Rec Run", "Build record run time code index");
prop = RNA_def_property(srna, "build_free_run", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, nullptr, "build_tc_flag", IMB_TC_FREE_RUN);
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_ui_text(prop, "Free Run", "Build free run time code index");
prop = RNA_def_property(srna, "build_free_run_rec_date", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(
prop, nullptr, "build_tc_flag", IMB_TC_INTERPOLATED_REC_DATE_FREE_RUN);
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_ui_text(
prop, "Free Run (Rec Date)", "Build free run time code index using Record Date/Time");
/* quality of proxied image */
prop = RNA_def_property(srna, "quality", PROP_INT, PROP_UNSIGNED);
RNA_def_property_int_sdna(prop, nullptr, "quality");

34
source/blender/makesrna/intern/rna_sequencer.cc
View File

@@ -1789,29 +1789,23 @@ static void rna_def_strip_proxy(BlenderRNA *brna)
PropertyRNA *prop;
static const EnumPropertyItem seq_tc_items[] = {
{SEQ_PROXY_TC_NONE, "NONE", 0, "None", ""},
{SEQ_PROXY_TC_NONE,
"NONE",
0,
"None",
"Ignore generated timecodes, seek in movie stream based on calculated timestamp"},
{SEQ_PROXY_TC_RECORD_RUN,
"RECORD_RUN",
0,
"Record Run",
"Use images in the order as they are recorded"},
{SEQ_PROXY_TC_FREE_RUN,
"FREE_RUN",
0,
"Free Run",
"Use global timestamp written by recording device"},
{SEQ_PROXY_TC_INTERP_REC_DATE_FREE_RUN,
"FREE_RUN_REC_DATE",
0,
"Free Run (rec date)",
"Interpolate a global timestamp using the "
"record date and time written by recording device"},
"Seek based on timestamps read from movie stream, giving the best match between scene and "
"movie times"},
{SEQ_PROXY_TC_RECORD_RUN_NO_GAPS,
"RECORD_RUN_NO_GAPS",
0,
"Record Run No Gaps",
"Like record run, but ignore timecode, "
"changes in framerate or dropouts"},
"Effectively convert movie to an image sequence, ignoring incomplete or dropped frames, "
"and changes in frame rate"},
{0, nullptr, 0, nullptr, nullptr},
};
@@ -1858,16 +1852,6 @@ static void rna_def_strip_proxy(BlenderRNA *brna)
RNA_def_property_boolean_sdna(prop, nullptr, "build_tc_flags", SEQ_PROXY_TC_RECORD_RUN);
RNA_def_property_ui_text(prop, "Rec Run", "Build record run time code index");
prop = RNA_def_property(srna, "build_free_run", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, nullptr, "build_tc_flags", SEQ_PROXY_TC_FREE_RUN);
RNA_def_property_ui_text(prop, "Free Run", "Build free run time code index");
prop = RNA_def_property(srna, "build_free_run_rec_date", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(
prop, nullptr, "build_tc_flags", SEQ_PROXY_TC_INTERP_REC_DATE_FREE_RUN);
RNA_def_property_ui_text(
prop, "Free Run (Rec Date)", "Build free run time code index using Record Date/Time");
prop = RNA_def_property(srna, "quality", PROP_INT, PROP_UNSIGNED);
RNA_def_property_int_sdna(prop, nullptr, "quality");
RNA_def_property_ui_text(prop, "Quality", "Quality of proxies to build");

2
source/blender/sequencer/intern/sequencer.cc
View File

@@ -61,7 +61,7 @@ StripProxy *seq_strip_proxy_alloc()
StripProxy *strip_proxy = static_cast<StripProxy *>(
MEM_callocN(sizeof(StripProxy), "StripProxy"));
strip_proxy->quality = 50;
strip_proxy->build_tc_flags = SEQ_PROXY_TC_ALL;
strip_proxy->build_tc_flags = SEQ_PROXY_TC_RECORD_RUN | SEQ_PROXY_TC_RECORD_RUN_NO_GAPS;
strip_proxy->tc = SEQ_PROXY_TC_RECORD_RUN;
return strip_proxy;
}