Improvements and fixes to Cycles metadata
[blender.git] / source / blender / editors / space_clip / clip_buttons.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2011 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file \ingroup spclip
21  */
22
23 #include <string.h>
24 #include <stdio.h>
25
26 #include "MEM_guardedalloc.h"
27
28 #include "DNA_scene_types.h"
29 #include "DNA_screen_types.h"
30 #include "DNA_space_types.h"
31
32 #include "BLI_utildefines.h"
33 #include "BLI_listbase.h"
34 #include "BLI_math.h"
35 #include "BLI_path_util.h"
36 #include "BLI_string.h"
37
38 #include "BLT_translation.h"
39
40 #include "BKE_context.h"
41 #include "BKE_screen.h"
42 #include "BKE_movieclip.h"
43 #include "BKE_tracking.h"
44
45 #include "DEG_depsgraph.h"
46
47 #include "ED_clip.h"
48 #include "ED_gpencil.h"
49 #include "ED_screen.h"
50
51 #include "UI_interface.h"
52 #include "UI_resources.h"
53
54 #include "RNA_access.h"
55
56 #include "WM_api.h"
57 #include "WM_types.h"
58
59 #include "IMB_imbuf_types.h"
60 #include "IMB_imbuf.h"
61
62 #include "clip_intern.h"  /* own include */
63
64 /* Panels */
65
66 static bool metadata_panel_context_poll(const bContext *C, PanelType *UNUSED(pt))
67 {
68         return ED_space_clip_poll((bContext *)C);
69 }
70
71 static void metadata_panel_context_draw(const bContext *C, Panel *panel)
72 {
73         SpaceClip *space_clip = CTX_wm_space_clip(C);
74         /* NOTE: This might not be exactly the same image buffer as shown in the
75          * clip editor itself, since that might be coming from proxy, or being
76          * postprocessed (stabilized or undistored).
77          * Ideally we need to query metadata from an original image or movie without
78          * reading actual pixels to speed up the process. */
79         ImBuf *ibuf = ED_space_clip_get_buffer(space_clip);
80         if (ibuf != NULL) {
81                 ED_region_image_metadata_panel_draw(ibuf, panel->layout);
82                 IMB_freeImBuf(ibuf);
83         }
84 }
85
86 void ED_clip_buttons_register(ARegionType *art)
87 {
88         PanelType *pt;
89
90         pt = MEM_callocN(sizeof(PanelType), "spacetype clip panel metadata");
91         strcpy(pt->idname, "CLIP_PT_metadata");
92         strcpy(pt->label, N_("Metadata"));
93         strcpy(pt->category, "Footage");
94         strcpy(pt->translation_context, BLT_I18NCONTEXT_DEFAULT_BPYRNA);
95         pt->poll = metadata_panel_context_poll;
96         pt->draw = metadata_panel_context_draw;
97         BLI_addtail(&art->paneltypes, pt);
98 }
99
100 /********************* MovieClip Template ************************/
101
102 void uiTemplateMovieClip(uiLayout *layout, bContext *C, PointerRNA *ptr, const char *propname, bool compact)
103 {
104         PropertyRNA *prop;
105         PointerRNA clipptr;
106         MovieClip *clip;
107         uiLayout *row, *split;
108         uiBlock *block;
109
110         if (!ptr->data)
111                 return;
112
113         prop = RNA_struct_find_property(ptr, propname);
114         if (!prop) {
115                 printf("%s: property not found: %s.%s\n",
116                        __func__, RNA_struct_identifier(ptr->type), propname);
117                 return;
118         }
119
120         if (RNA_property_type(prop) != PROP_POINTER) {
121                 printf("%s: expected pointer property for %s.%s\n",
122                        __func__, RNA_struct_identifier(ptr->type), propname);
123                 return;
124         }
125
126         clipptr = RNA_property_pointer_get(ptr, prop);
127         clip = clipptr.data;
128
129         uiLayoutSetContextPointer(layout, "edit_movieclip", &clipptr);
130
131         if (!compact)
132                 uiTemplateID(layout, C, ptr, propname, NULL, "CLIP_OT_open", NULL, UI_TEMPLATE_ID_FILTER_ALL, false);
133
134         if (clip) {
135                 uiLayout *col;
136
137                 row = uiLayoutRow(layout, false);
138                 block = uiLayoutGetBlock(row);
139                 uiDefBut(block, UI_BTYPE_LABEL, 0, IFACE_("File Path:"), 0, 19, 145, 19, NULL, 0, 0, 0, 0, "");
140
141                 row = uiLayoutRow(layout, false);
142                 split = uiLayoutSplit(row, 0.0f, false);
143                 row = uiLayoutRow(split, true);
144
145                 uiItemR(row, &clipptr, "filepath", 0, "", ICON_NONE);
146                 uiItemO(row, "", ICON_FILE_REFRESH, "clip.reload");
147
148                 col = uiLayoutColumn(layout, false);
149                 uiTemplateColorspaceSettings(col, &clipptr, "colorspace_settings");
150         }
151 }
152
153 /********************* Track Template ************************/
154
155 void uiTemplateTrack(uiLayout *layout, PointerRNA *ptr, const char *propname)
156 {
157         PropertyRNA *prop;
158         PointerRNA scopesptr;
159         uiBlock *block;
160         uiLayout *col;
161         MovieClipScopes *scopes;
162
163         if (!ptr->data)
164                 return;
165
166         prop = RNA_struct_find_property(ptr, propname);
167         if (!prop) {
168                 printf("%s: property not found: %s.%s\n",
169                        __func__, RNA_struct_identifier(ptr->type), propname);
170                 return;
171         }
172
173         if (RNA_property_type(prop) != PROP_POINTER) {
174                 printf("%s: expected pointer property for %s.%s\n",
175                        __func__, RNA_struct_identifier(ptr->type), propname);
176                 return;
177         }
178
179         scopesptr = RNA_property_pointer_get(ptr, prop);
180         scopes = (MovieClipScopes *)scopesptr.data;
181
182         if (scopes->track_preview_height < UI_UNIT_Y) {
183                 scopes->track_preview_height = UI_UNIT_Y;
184         }
185         else if (scopes->track_preview_height > UI_UNIT_Y * 20) {
186                 scopes->track_preview_height = UI_UNIT_Y * 20;
187         }
188
189         col = uiLayoutColumn(layout, true);
190         block = uiLayoutGetBlock(col);
191
192         uiDefBut(block, UI_BTYPE_TRACK_PREVIEW, 0, "", 0, 0, UI_UNIT_X * 10, scopes->track_preview_height, scopes, 0, 0, 0, 0, "");
193
194         /* Resize grip. */
195         uiDefIconButI(block, UI_BTYPE_GRIP, 0, ICON_GRIP, 0, 0, UI_UNIT_X * 10, (short)(UI_UNIT_Y * 0.8f),
196                       &scopes->track_preview_height, UI_UNIT_Y, UI_UNIT_Y * 20.0f, 0.0f, 0.0f, "");
197 }
198
199 /********************* Marker Template ************************/
200
201 #define B_MARKER_POS            3
202 #define B_MARKER_OFFSET         4
203 #define B_MARKER_PAT_DIM        5
204 #define B_MARKER_SEARCH_POS     6
205 #define B_MARKER_SEARCH_DIM     7
206 #define B_MARKER_FLAG           8
207
208 typedef struct {
209         /** compact mode */
210         int compact;
211
212         MovieClip *clip;
213         /** user of clip */
214         MovieClipUser *user;
215         MovieTrackingTrack *track;
216         MovieTrackingMarker *marker;
217
218         /** current frame number */
219         int framenr;
220         /** position of marker in pixel coords */
221         float marker_pos[2];
222         /** position and dimensions of marker pattern in pixel coords */
223         float marker_pat[2];
224         /** offset of "parenting" point */
225         float track_offset[2];
226         /** position and dimensions of marker search in pixel coords */
227         float marker_search_pos[2], marker_search[2];
228         /** marker's flags */
229         int marker_flag;
230 } MarkerUpdateCb;
231
232 static void to_pixel_space(float r[2], float a[2], int width, int height)
233 {
234         copy_v2_v2(r, a);
235         r[0] *= width;
236         r[1] *= height;
237 }
238
239 static void marker_update_cb(bContext *C, void *arg_cb, void *UNUSED(arg))
240 {
241         MarkerUpdateCb *cb = (MarkerUpdateCb *) arg_cb;
242         MovieTrackingMarker *marker;
243
244         if (!cb->compact)
245                 return;
246
247         marker = BKE_tracking_marker_ensure(cb->track, cb->framenr);
248
249         marker->flag = cb->marker_flag;
250
251         WM_event_add_notifier(C, NC_MOVIECLIP | NA_EDITED, NULL);
252 }
253
254 static void marker_block_handler(bContext *C, void *arg_cb, int event)
255 {
256         MarkerUpdateCb *cb = (MarkerUpdateCb *) arg_cb;
257         MovieTrackingMarker *marker;
258         int width, height;
259         bool ok = false;
260
261         BKE_movieclip_get_size(cb->clip, cb->user, &width, &height);
262
263         marker = BKE_tracking_marker_ensure(cb->track, cb->framenr);
264
265         if (event == B_MARKER_POS) {
266                 marker->pos[0] = cb->marker_pos[0] / width;
267                 marker->pos[1] = cb->marker_pos[1] / height;
268
269                 /* to update position of "parented" objects */
270                 DEG_id_tag_update(&cb->clip->id, 0);
271                 WM_event_add_notifier(C, NC_SPACE | ND_SPACE_VIEW3D, NULL);
272
273                 ok = true;
274         }
275         else if (event == B_MARKER_PAT_DIM) {
276                 float dim[2], pat_dim[2], pat_min[2], pat_max[2];
277                 float scale_x, scale_y;
278                 int a;
279
280                 BKE_tracking_marker_pattern_minmax(cb->marker, pat_min, pat_max);
281
282                 sub_v2_v2v2(pat_dim, pat_max, pat_min);
283
284                 dim[0] = cb->marker_pat[0] / width;
285                 dim[1] = cb->marker_pat[1] / height;
286
287                 scale_x = dim[0] / pat_dim[0];
288                 scale_y = dim[1] / pat_dim[1];
289
290                 for (a = 0; a < 4; a++) {
291                         cb->marker->pattern_corners[a][0] *= scale_x;
292                         cb->marker->pattern_corners[a][1] *= scale_y;
293                 }
294
295                 BKE_tracking_marker_clamp(cb->marker, CLAMP_PAT_DIM);
296
297                 ok = true;
298         }
299         else if (event == B_MARKER_SEARCH_POS) {
300                 float delta[2], side[2];
301
302                 sub_v2_v2v2(side, cb->marker->search_max, cb->marker->search_min);
303                 mul_v2_fl(side, 0.5f);
304
305                 delta[0] = cb->marker_search_pos[0] / width;
306                 delta[1] = cb->marker_search_pos[1] / height;
307
308                 sub_v2_v2v2(cb->marker->search_min, delta, side);
309                 add_v2_v2v2(cb->marker->search_max, delta, side);
310
311                 BKE_tracking_marker_clamp(cb->marker, CLAMP_SEARCH_POS);
312
313                 ok = true;
314         }
315         else if (event == B_MARKER_SEARCH_DIM) {
316                 float dim[2], search_dim[2];
317
318                 sub_v2_v2v2(search_dim, cb->marker->search_max, cb->marker->search_min);
319
320                 dim[0] = cb->marker_search[0] / width;
321                 dim[1] = cb->marker_search[1] / height;
322
323                 sub_v2_v2(dim, search_dim);
324                 mul_v2_fl(dim, 0.5f);
325
326                 cb->marker->search_min[0] -= dim[0];
327                 cb->marker->search_min[1] -= dim[1];
328
329                 cb->marker->search_max[0] += dim[0];
330                 cb->marker->search_max[1] += dim[1];
331
332                 BKE_tracking_marker_clamp(cb->marker, CLAMP_SEARCH_DIM);
333
334                 ok = true;
335         }
336         else if (event == B_MARKER_FLAG) {
337                 marker->flag = cb->marker_flag;
338
339                 ok = true;
340         }
341         else if (event == B_MARKER_OFFSET) {
342                 float offset[2], delta[2];
343                 int i;
344
345                 offset[0] = cb->track_offset[0] / width;
346                 offset[1] = cb->track_offset[1] / height;
347
348                 sub_v2_v2v2(delta, offset, cb->track->offset);
349                 copy_v2_v2(cb->track->offset, offset);
350
351                 for (i = 0; i < cb->track->markersnr; i++)
352                         sub_v2_v2(cb->track->markers[i].pos, delta);
353
354                 /* to update position of "parented" objects */
355                 DEG_id_tag_update(&cb->clip->id, 0);
356                 WM_event_add_notifier(C, NC_SPACE | ND_SPACE_VIEW3D, NULL);
357
358                 ok = true;
359         }
360
361         if (ok)
362                 WM_event_add_notifier(C, NC_MOVIECLIP | NA_EDITED, cb->clip);
363 }
364
365 void uiTemplateMarker(uiLayout *layout, PointerRNA *ptr, const char *propname, PointerRNA *userptr,
366                       PointerRNA *trackptr, bool compact)
367 {
368         PropertyRNA *prop;
369         uiBlock *block;
370         uiBut *bt;
371         PointerRNA clipptr;
372         MovieClip *clip;
373         MovieClipUser *user;
374         MovieTrackingTrack *track;
375         MovieTrackingMarker *marker;
376         MarkerUpdateCb *cb;
377         const char *tip;
378         float pat_min[2], pat_max[2];
379
380         if (!ptr->data)
381                 return;
382
383         prop = RNA_struct_find_property(ptr, propname);
384         if (!prop) {
385                 printf("%s: property not found: %s.%s\n",
386                        __func__, RNA_struct_identifier(ptr->type), propname);
387                 return;
388         }
389
390         if (RNA_property_type(prop) != PROP_POINTER) {
391                 printf("%s: expected pointer property for %s.%s\n",
392                        __func__, RNA_struct_identifier(ptr->type), propname);
393                 return;
394         }
395
396         clipptr = RNA_property_pointer_get(ptr, prop);
397         clip = (MovieClip *)clipptr.data;
398         user = userptr->data;
399         track = trackptr->data;
400
401         marker = BKE_tracking_marker_get(track, user->framenr);
402
403         cb = MEM_callocN(sizeof(MarkerUpdateCb), "uiTemplateMarker update_cb");
404         cb->compact = compact;
405         cb->clip = clip;
406         cb->user = user;
407         cb->track = track;
408         cb->marker = marker;
409         cb->marker_flag = marker->flag;
410         cb->framenr = user->framenr;
411
412         if (compact) {
413                 block = uiLayoutGetBlock(layout);
414
415                 if (cb->marker_flag & MARKER_DISABLED)
416                         tip = TIP_("Marker is disabled at current frame");
417                 else
418                         tip = TIP_("Marker is enabled at current frame");
419
420                 bt = uiDefIconButBitI(block, UI_BTYPE_TOGGLE_N, MARKER_DISABLED, 0, ICON_HIDE_OFF, 0, 0, UI_UNIT_X, UI_UNIT_Y,
421                                       &cb->marker_flag, 0, 0, 1, 0, tip);
422                 UI_but_funcN_set(bt, marker_update_cb, cb, NULL);
423                 UI_but_drawflag_enable(bt, UI_BUT_ICON_REVERSE);
424         }
425         else {
426                 int width, height, step, digits;
427                 float pat_dim[2], search_dim[2], search_pos[2];
428                 uiLayout *col;
429
430                 BKE_movieclip_get_size(clip, user, &width, &height);
431
432                 if (track->flag & TRACK_LOCKED) {
433                         uiLayoutSetActive(layout, false);
434                         block = uiLayoutAbsoluteBlock(layout);
435                         uiDefBut(block, UI_BTYPE_LABEL, 0, IFACE_("Track is locked"), 0, 0, UI_UNIT_X * 15.0f, UI_UNIT_Y, NULL, 0, 0, 0, 0, "");
436
437                         return;
438                 }
439
440                 step = 100;
441                 digits = 2;
442
443                 BKE_tracking_marker_pattern_minmax(marker, pat_min, pat_max);
444
445                 sub_v2_v2v2(pat_dim, pat_max, pat_min);
446                 sub_v2_v2v2(search_dim, marker->search_max, marker->search_min);
447
448                 add_v2_v2v2(search_pos, marker->search_max, marker->search_min);
449                 mul_v2_fl(search_pos, 0.5);
450
451                 to_pixel_space(cb->marker_pos, marker->pos, width, height);
452                 to_pixel_space(cb->marker_pat, pat_dim, width, height);
453                 to_pixel_space(cb->marker_search, search_dim, width, height);
454                 to_pixel_space(cb->marker_search_pos, search_pos, width, height);
455                 to_pixel_space(cb->track_offset, track->offset, width, height);
456
457                 cb->marker_flag = marker->flag;
458
459                 block = uiLayoutAbsoluteBlock(layout);
460                 UI_block_func_handle_set(block, marker_block_handler, cb);
461                 UI_block_funcN_set(block, marker_update_cb, cb, NULL);
462
463                 if (cb->marker_flag & MARKER_DISABLED)
464                         tip = TIP_("Marker is disabled at current frame");
465                 else
466                         tip = TIP_("Marker is enabled at current frame");
467
468                 uiDefButBitI(block, UI_BTYPE_CHECKBOX_N, MARKER_DISABLED, B_MARKER_FLAG, IFACE_("Enabled"), 0.5 * UI_UNIT_X, 9.5 * UI_UNIT_Y, 7.25 * UI_UNIT_X, UI_UNIT_Y,
469                              &cb->marker_flag, 0, 0, 0, 0, tip);
470
471                 col = uiLayoutColumn(layout, true);
472                 uiLayoutSetActive(col, (cb->marker_flag & MARKER_DISABLED) == 0);
473
474                 block = uiLayoutAbsoluteBlock(col);
475                 UI_block_align_begin(block);
476
477                 uiDefBut(block, UI_BTYPE_LABEL, 0, IFACE_("Position:"), 0, 10 * UI_UNIT_Y, 15 * UI_UNIT_X, UI_UNIT_Y, NULL, 0, 0, 0, 0, "");
478                 uiDefButF(block, UI_BTYPE_NUM, B_MARKER_POS, IFACE_("X:"), 0.5 * UI_UNIT_X, 9 * UI_UNIT_Y, 7.25 * UI_UNIT_X, UI_UNIT_Y, &cb->marker_pos[0],
479                           -10 * width, 10.0 * width, step, digits, TIP_("X-position of marker at frame in screen coordinates"));
480                 uiDefButF(block, UI_BTYPE_NUM, B_MARKER_POS, IFACE_("Y:"), 8.25 * UI_UNIT_X, 9 * UI_UNIT_Y, 7.25 * UI_UNIT_X, UI_UNIT_Y, &cb->marker_pos[1],
481                           -10 * height, 10.0 * height, step, digits,
482                           TIP_("Y-position of marker at frame in screen coordinates"));
483
484                 uiDefBut(block, UI_BTYPE_LABEL, 0, IFACE_("Offset:"), 0, 8 * UI_UNIT_Y, 15 * UI_UNIT_X, UI_UNIT_Y, NULL, 0, 0, 0, 0, "");
485                 uiDefButF(block, UI_BTYPE_NUM, B_MARKER_OFFSET, IFACE_("X:"), 0.5 * UI_UNIT_X, 7 * UI_UNIT_Y, 7.25 * UI_UNIT_X, UI_UNIT_Y, &cb->track_offset[0],
486                           -10 * width, 10.0 * width, step, digits, TIP_("X-offset to parenting point"));
487                 uiDefButF(block, UI_BTYPE_NUM, B_MARKER_OFFSET, IFACE_("Y:"), 8.25 * UI_UNIT_X, 7 * UI_UNIT_Y, 7.25 * UI_UNIT_X, UI_UNIT_Y, &cb->track_offset[1],
488                           -10 * height, 10.0 * height, step, digits, TIP_("Y-offset to parenting point"));
489
490                 uiDefBut(block, UI_BTYPE_LABEL, 0, IFACE_("Pattern Area:"), 0, 6 * UI_UNIT_Y, 15 * UI_UNIT_X, UI_UNIT_Y, NULL, 0, 0, 0, 0, "");
491                 uiDefButF(block, UI_BTYPE_NUM, B_MARKER_PAT_DIM, IFACE_("Width:"), 0.5 * UI_UNIT_X, 5 * UI_UNIT_Y, 15 * UI_UNIT_X, UI_UNIT_Y, &cb->marker_pat[0], 3.0f,
492                           10.0 * width, step, digits, TIP_("Width of marker's pattern in screen coordinates"));
493                 uiDefButF(block, UI_BTYPE_NUM, B_MARKER_PAT_DIM, IFACE_("Height:"), 0.5 * UI_UNIT_X, 4 * UI_UNIT_Y, 15 * UI_UNIT_X, UI_UNIT_Y, &cb->marker_pat[1], 3.0f,
494                           10.0 * height, step, digits, TIP_("Height of marker's pattern in screen coordinates"));
495
496                 uiDefBut(block, UI_BTYPE_LABEL, 0, IFACE_("Search Area:"), 0, 3 * UI_UNIT_Y, 15 * UI_UNIT_X, UI_UNIT_Y, NULL, 0, 0, 0, 0, "");
497                 uiDefButF(block, UI_BTYPE_NUM, B_MARKER_SEARCH_POS, IFACE_("X:"), 0.5 * UI_UNIT_X, 2 * UI_UNIT_Y, 7.25 * UI_UNIT_X, UI_UNIT_Y, &cb->marker_search_pos[0],
498                           -width, width, step, digits, TIP_("X-position of search at frame relative to marker's position"));
499                 uiDefButF(block, UI_BTYPE_NUM, B_MARKER_SEARCH_POS, IFACE_("Y:"), 8.25 * UI_UNIT_X, 2 * UI_UNIT_Y, 7.25 * UI_UNIT_X, UI_UNIT_Y, &cb->marker_search_pos[1],
500                           -height, height, step, digits, TIP_("Y-position of search at frame relative to marker's position"));
501                 uiDefButF(block, UI_BTYPE_NUM, B_MARKER_SEARCH_DIM, IFACE_("Width:"), 0.5 * UI_UNIT_X, 1 * UI_UNIT_Y, 15 * UI_UNIT_X, UI_UNIT_Y, &cb->marker_search[0], 3.0f,
502                           10.0 * width, step, digits, TIP_("Width of marker's search in screen coordinates"));
503                 uiDefButF(block, UI_BTYPE_NUM, B_MARKER_SEARCH_DIM, IFACE_("Height:"), 0.5 * UI_UNIT_X, 0 * UI_UNIT_Y, 15 * UI_UNIT_X, UI_UNIT_Y, &cb->marker_search[1], 3.0f,
504                           10.0 * height, step, digits, TIP_("Height of marker's search in screen coordinates"));
505
506                 UI_block_align_end(block);
507         }
508 }
509
510 /********************* Footage Information Template ************************/
511
512 void uiTemplateMovieclipInformation(uiLayout *layout, PointerRNA *ptr, const char *propname, PointerRNA *userptr)
513 {
514         PropertyRNA *prop;
515         PointerRNA clipptr;
516         MovieClip *clip;
517         MovieClipUser *user;
518         uiLayout *col;
519         char str[1024];
520         int width, height, framenr;
521         ImBuf *ibuf;
522         size_t ofs = 0;
523
524         if (!ptr->data)
525                 return;
526
527         prop = RNA_struct_find_property(ptr, propname);
528         if (!prop) {
529                 printf("%s: property not found: %s.%s\n",
530                        __func__, RNA_struct_identifier(ptr->type), propname);
531                 return;
532         }
533
534         if (RNA_property_type(prop) != PROP_POINTER) {
535                 printf("%s: expected pointer property for %s.%s\n",
536                        __func__, RNA_struct_identifier(ptr->type), propname);
537                 return;
538         }
539
540         clipptr = RNA_property_pointer_get(ptr, prop);
541         clip = (MovieClip *)clipptr.data;
542         user = userptr->data;
543
544         col = uiLayoutColumn(layout, false);
545
546         ibuf = BKE_movieclip_get_ibuf_flag(clip, user, clip->flag, MOVIECLIP_CACHE_SKIP);
547
548         /* Display frame dimensions, channels number and byffer type. */
549         BKE_movieclip_get_size(clip, user, &width, &height);
550         ofs += BLI_snprintf(str + ofs, sizeof(str) - ofs, IFACE_("Size %d x %d"), width, height);
551
552         if (ibuf) {
553                 if (ibuf->rect_float) {
554                         if (ibuf->channels != 4)
555                                 ofs += BLI_snprintf(str + ofs, sizeof(str) - ofs, IFACE_(", %d float channel(s)"), ibuf->channels);
556                         else if (ibuf->planes == R_IMF_PLANES_RGBA)
557                                 ofs += BLI_strncpy_rlen(str + ofs, IFACE_(", RGBA float"), sizeof(str) - ofs);
558                         else
559                                 ofs += BLI_strncpy_rlen(str + ofs, IFACE_(", RGB float"), sizeof(str) - ofs);
560                 }
561                 else {
562                         if (ibuf->planes == R_IMF_PLANES_RGBA)
563                                 ofs += BLI_strncpy_rlen(str + ofs, IFACE_(", RGBA byte"), sizeof(str) - ofs);
564                         else
565                                 ofs += BLI_strncpy_rlen(str + ofs, IFACE_(", RGB byte"), sizeof(str) - ofs);
566                 }
567
568                 if (clip->anim != NULL) {
569                         short frs_sec;
570                         float frs_sec_base;
571                         if (IMB_anim_get_fps(clip->anim, &frs_sec, &frs_sec_base, true)) {
572                                 ofs += BLI_snprintf(str + ofs, sizeof(str) - ofs,
573                                                     IFACE_(", %.2f fps"),
574                                                     (float)frs_sec / frs_sec_base);
575                         }
576                 }
577         }
578         else {
579                 ofs += BLI_strncpy_rlen(str + ofs, IFACE_(", failed to load"), sizeof(str) - ofs);
580         }
581
582         uiItemL(col, str, ICON_NONE);
583
584         /* Display current frame number. */
585         framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, user->framenr);
586         if (framenr <= clip->len)
587                 BLI_snprintf(str, sizeof(str), IFACE_("Frame: %d / %d"), framenr, clip->len);
588         else
589                 BLI_snprintf(str, sizeof(str), IFACE_("Frame: - / %d"), clip->len);
590         uiItemL(col, str, ICON_NONE);
591
592         /* Display current file name if it's a sequence clip. */
593         if (clip->source == MCLIP_SRC_SEQUENCE) {
594                 char filepath[FILE_MAX];
595                 const char *file;
596
597                 if (framenr <= clip->len) {
598                         BKE_movieclip_filename_for_frame(clip, user, filepath);
599                         file = BLI_last_slash(filepath);
600                 }
601                 else {
602                         file = "-";
603                 }
604
605                 BLI_snprintf(str, sizeof(str), IFACE_("File: %s"), file);
606
607                 uiItemL(col, str, ICON_NONE);
608         }
609
610         IMB_freeImBuf(ibuf);
611 }