4 * Copyright (C) 1997-2011 Adam Williams <broadcast at earthling dot net>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
30 #include "timeavgwindow.h"
31 #include "transportque.h"
43 REGISTER_PLUGIN(TimeAvgMain)
49 TimeAvgConfig::TimeAvgConfig()
52 mode = TimeAvgConfig::AVERAGE;
59 void TimeAvgConfig::copy_from(TimeAvgConfig *src)
61 this->frames = src->frames;
62 this->mode = src->mode;
63 this->paranoid = src->paranoid;
64 this->nosubtract = src->nosubtract;
65 this->threshold = src->threshold;
66 this->border = src->border;
69 int TimeAvgConfig::equivalent(TimeAvgConfig *src)
71 return frames == src->frames &&
73 paranoid == src->paranoid &&
74 nosubtract == src->nosubtract &&
75 threshold == src->threshold &&
76 border == src->border;
91 TimeAvgMain::TimeAvgMain(PluginServer *server)
92 : PluginVClient(server)
98 history_start = -0x7fffffff;
104 TimeAvgMain::~TimeAvgMain()
108 if(accumulation) delete [] accumulation;
111 for(int i = 0; i < config.frames; i++)
115 if(history_frame) delete [] history_frame;
116 if(history_valid) delete [] history_valid;
119 const char* TimeAvgMain::plugin_title() { return _("Time Average"); }
120 int TimeAvgMain::is_realtime() { return 1; }
124 NEW_WINDOW_MACRO(TimeAvgMain, TimeAvgWindow);
128 int TimeAvgMain::process_buffer(VFrame *frame,
129 int64_t start_position,
132 int h = frame->get_h();
133 int w = frame->get_w();
134 int color_model = frame->get_color_model();
136 int reset = load_configuration();
138 // reset buffer on the keyframes
139 int64_t actual_previous_number = start_position;
140 if(get_direction() == PLAY_FORWARD)
142 actual_previous_number--;
143 if(actual_previous_number < get_source_start())
147 KeyFrame *keyframe = get_prev_keyframe(start_position, 1);
148 if(keyframe->position > 0 &&
149 actual_previous_number < keyframe->position)
155 actual_previous_number++;
156 if(actual_previous_number >= get_source_start() + get_total_len())
160 KeyFrame *keyframe = get_next_keyframe(start_position, 1);
161 if(keyframe->position > 0 &&
162 actual_previous_number >= keyframe->position)
167 // Allocate accumulation
168 if(!accumulation || reset)
170 if(!accumulation) accumulation = new unsigned char[w *
172 BC_CModels::components(color_model) *
173 MAX(sizeof(float), sizeof(int))];
174 reset_accum(w, h, color_model);
177 if(!config.nosubtract &&
178 (config.mode == TimeAvgConfig::AVERAGE ||
179 config.mode == TimeAvgConfig::ACCUMULATE ||
180 config.mode == TimeAvgConfig::GREATER ||
181 config.mode == TimeAvgConfig::LESS))
183 // Reallocate history
186 if(config.frames != history_size)
189 int64_t *history_frame2;
191 history2 = new VFrame*[config.frames];
192 history_frame2 = new int64_t[config.frames];
193 history_valid2 = new int[config.frames];
195 // Copy existing frames over
197 for(i = 0, j = 0; i < config.frames && j < history_size; i++, j++)
199 history2[i] = history[j];
200 history_frame2[i] = history_frame[i];
201 history_valid2[i] = history_valid[i];
204 // Delete extra previous frames and subtract from accumulation
205 for( ; j < history_size; j++)
207 subtract_accum(history[j]);
211 delete [] history_frame;
212 delete [] history_valid;
216 for( ; i < config.frames; i++)
218 history2[i] = new VFrame(w, h, color_model);
219 history_frame2[i] = -0x7fffffff;
220 history_valid2[i] = 0;
224 history_frame = history_frame2;
225 history_valid = history_valid2;
227 history_size = config.frames;
233 history = new VFrame*[config.frames];
234 for(int i = 0; i < config.frames; i++)
235 history[i] = new VFrame(w, h, color_model);
236 history_size = config.frames;
237 history_frame = new int64_t[config.frames];
238 bzero(history_frame, sizeof(int64_t) * config.frames);
239 history_valid = new int[config.frames];
240 bzero(history_valid, sizeof(int) * config.frames);
243 //printf("TimeAvgMain::process_buffer %d\n", __LINE__);
248 // Create new history frames based on current frame
249 int64_t *new_history_frames = new int64_t[history_size];
250 for(int i = 0; i < history_size; i++)
252 new_history_frames[history_size - i - 1] = start_position - i;
255 // Subtract old history frames from accumulation buffer
256 // which are not in the new vector
258 for(int i = 0; i < history_size; i++)
260 // Old frame is valid
264 for(int j = 0; j < history_size; j++)
266 // Old frame is equal to a new frame
267 if(history_frame[i] == new_history_frames[j])
274 // Didn't find old frame in new frames
277 if(config.mode == TimeAvgConfig::AVERAGE ||
278 config.mode == TimeAvgConfig::ACCUMULATE)
280 subtract_accum(history[i]);
283 history_valid[i] = 0;
288 // If all frames are still valid, assume tweek occurred upstream and reload.
289 if(config.paranoid && no_change)
291 for(int i = 0; i < history_size; i++)
293 history_valid[i] = 0;
296 if(config.mode == TimeAvgConfig::AVERAGE ||
297 config.mode == TimeAvgConfig::ACCUMULATE)
299 reset_accum(w, h, color_model);
303 // Add new history frames which are not in the old vector
304 for(int i = 0; i < history_size; i++)
306 // Find new frame in old vector
308 for(int j = 0; j < history_size; j++)
310 if(history_valid[j] && history_frame[j] == new_history_frames[i])
317 // Didn't find new frame in old vector
320 // Get first unused entry
321 for(int j = 0; j < history_size; j++)
323 if(!history_valid[j])
325 // Load new frame into it
326 history_frame[j] = new_history_frames[i];
327 history_valid[j] = 1;
328 read_frame(history[j],
332 if(config.mode == TimeAvgConfig::AVERAGE ||
333 config.mode == TimeAvgConfig::ACCUMULATE)
335 add_accum(history[j]);
342 delete [] new_history_frames;
345 // No history subtraction
349 for(int i = 0; i < config.frames; i++)
355 if(history_frame) delete [] history_frame;
356 if(history_valid) delete [] history_valid;
361 // Clamp prev_frame to history size
362 prev_frame = MAX(start_position - config.frames + 1, prev_frame);
364 // Force reload if not repositioned or just started
365 if( (config.paranoid && prev_frame == start_position) ||
368 //printf("TimeAvgMain::process_buffer %d\n", __LINE__);
369 prev_frame = start_position - config.frames + 1;
370 prev_frame = MAX(0, prev_frame);
371 reset_accum(w, h, color_model);
374 // printf("TimeAvgMain::process_buffer %d prev_frame=" _LD " start_position=" _LD "\n",
375 // __LINE__, prev_frame, start_position);
376 for(int64_t i = prev_frame; i <= start_position; i++)
383 printf("TimeAvgMain::process_buffer %d prev_frame=" _LD " start_position=" _LD " i=" _LD "\n",
384 __LINE__, prev_frame, start_position, i);
387 // If we don't add 1, it rereads the frame again
388 prev_frame = start_position + 1;
397 // Transfer accumulation to output with division if average is desired.
398 transfer_accum(frame);
400 //printf("TimeAvgMain::process_buffer %d\n", __LINE__);
415 // Reset accumulation
416 #define SET_ACCUM(type, components, luma, chroma) \
418 type *row = (type*)accumulation; \
421 for(int i = 0; i < w * h; i++) \
426 if(components == 4) *row++ = luma; \
431 bzero(row, w * h * sizeof(type) * components); \
436 void TimeAvgMain::reset_accum(int w, int h, int color_model)
438 if(config.mode == TimeAvgConfig::LESS)
443 SET_ACCUM(int, 3, 0xff, 0xff)
446 SET_ACCUM(float, 3, 1.0, 1.0)
449 SET_ACCUM(int, 4, 0xff, 0xff)
452 SET_ACCUM(float, 4, 1.0, 1.0)
455 SET_ACCUM(int, 3, 0xff, 0x80)
458 SET_ACCUM(int, 4, 0xff, 0x80)
461 SET_ACCUM(int, 3, 0xffff, 0x8000)
463 case BC_YUVA16161616:
464 SET_ACCUM(int, 4, 0xffff, 0x8000)
473 SET_ACCUM(int, 3, 0x0, 0x0)
476 SET_ACCUM(float, 3, 0x0, 0x0)
479 SET_ACCUM(int, 4, 0x0, 0x0)
482 SET_ACCUM(float, 4, 0x0, 0x0)
485 SET_ACCUM(int, 3, 0x0, 0x80)
488 SET_ACCUM(int, 4, 0x0, 0x80)
491 SET_ACCUM(int, 3, 0x0, 0x8000)
493 case BC_YUVA16161616:
494 SET_ACCUM(int, 4, 0x0, 0x8000)
500 #define RGB_TO_VALUE(r, g, b) \
501 ((r) * R_TO_Y + (g) * G_TO_Y + (b) * B_TO_Y)
503 // Only AVERAGE and ACCUMULATE use this
504 #define SUBTRACT_ACCUM(type, \
509 for(int i = 0; i < h; i++) \
511 accum_type *accum_row = (accum_type*)accumulation + \
512 i * w * components; \
513 type *frame_row = (type*)frame->get_rows()[i]; \
514 for(int j = 0; j < w; j++) \
516 *accum_row++ -= *frame_row++; \
517 *accum_row++ -= (accum_type)*frame_row++ - chroma; \
518 *accum_row++ -= (accum_type)*frame_row++ - chroma; \
519 if(components == 4) *accum_row++ -= *frame_row++; \
525 void TimeAvgMain::subtract_accum(VFrame *frame)
528 if(config.nosubtract) return;
529 int w = frame->get_w();
530 int h = frame->get_h();
532 switch(frame->get_color_model())
535 SUBTRACT_ACCUM(unsigned char, int, 3, 0x0)
538 SUBTRACT_ACCUM(float, float, 3, 0x0)
541 SUBTRACT_ACCUM(unsigned char, int, 4, 0x0)
544 SUBTRACT_ACCUM(float, float, 4, 0x0)
547 SUBTRACT_ACCUM(unsigned char, int, 3, 0x80)
550 SUBTRACT_ACCUM(unsigned char, int, 4, 0x80)
553 SUBTRACT_ACCUM(uint16_t, int, 3, 0x8000)
555 case BC_YUVA16161616:
556 SUBTRACT_ACCUM(uint16_t, int, 4, 0x8000)
562 // The behavior has to be very specific to the color model because we rely on
563 // the value of full black to determine what pixel to show.
564 #define ADD_ACCUM(type, accum_type, components, chroma, max) \
566 if(config.mode == TimeAvgConfig::REPLACE) \
568 type threshold = config.threshold; \
569 if(sizeof(type) == 4) \
571 /* Compare all pixels if border */ \
572 if(config.border > 0) \
574 int border = config.border; \
575 int h_border = h - border - 1; \
576 int w_border = w - border - 1; \
577 int kernel_size = (border * 2 + 1) * (border * 2 + 1); \
578 for(int i = border; i < h_border; i++) \
580 for(int j = border; j < w_border; j++) \
583 for(int k = -border; k <= border; k++) \
585 type *frame_row = (type*)frame->get_rows()[i + k]; \
586 for(int l = -border; l <= border; l++) \
588 type *frame_pixel = frame_row + (j + l) * components; \
589 /* Compare alpha if 4 channel */ \
590 if(components == 4) \
592 if(frame_pixel[3] > threshold) \
596 if(sizeof(type) == 4) \
598 /* Compare luma if 3 channel */ \
599 if(RGB_TO_VALUE(frame_pixel[0], frame_pixel[1], frame_pixel[2]) >= \
608 if(frame_pixel[0] >= threshold) \
614 if(RGB_TO_VALUE(frame_pixel[0], frame_pixel[1], frame_pixel[2]) >= threshold) \
621 if(copy_it == kernel_size) \
623 accum_type *accum_row = (accum_type*)accumulation + \
624 i * w * components + j * components; \
625 type *frame_row = (type*)frame->get_rows()[i] + j * components; \
626 *accum_row++ = *frame_row++; \
627 *accum_row++ = *frame_row++; \
628 *accum_row++ = *frame_row++; \
629 if(components == 4) *accum_row++ = *frame_row++; \
636 /* Compare only relevant pixel if no border */ \
638 for(int i = 0; i < h; i++) \
640 accum_type *accum_row = (accum_type*)accumulation + \
641 i * w * components; \
642 type *frame_row = (type*)frame->get_rows()[i]; \
643 for(int j = 0; j < w; j++) \
646 /* Compare alpha if 4 channel */ \
647 if(components == 4) \
649 if(frame_row[3] > threshold) \
653 if(sizeof(type) == 4) \
655 /* Compare luma if 3 channel */ \
656 if(RGB_TO_VALUE(frame_row[0], frame_row[1], frame_row[2]) >= \
665 if(frame_row[0] >= threshold) \
671 if(RGB_TO_VALUE(frame_row[0], frame_row[1], frame_row[2]) >= threshold) \
678 *accum_row++ = *frame_row++; \
679 *accum_row++ = *frame_row++; \
680 *accum_row++ = *frame_row++; \
681 if(components == 4) *accum_row++ = *frame_row++; \
685 frame_row += components; \
686 accum_row += components; \
693 if(config.mode == TimeAvgConfig::GREATER) \
695 for(int i = 0; i < h; i++) \
697 accum_type *accum_row = (accum_type*)accumulation + \
698 i * w * components; \
699 type *frame_row = (type*)frame->get_rows()[i]; \
700 for(int j = 0; j < w; j++) \
703 /* Compare alpha if 4 channel */ \
704 if(components == 4) \
706 if(frame_row[3] > accum_row[3]) copy_it = 1; \
711 /* Compare YUV luma if 3 channel */ \
712 if(frame_row[0] > accum_row[0]) copy_it = 1; \
716 /* Compare RGB luma if 3 channel */ \
717 if(RGB_TO_VALUE(frame_row[0], frame_row[1], frame_row[2]) > \
718 RGB_TO_VALUE(accum_row[0], accum_row[1], accum_row[2])) \
724 *accum_row++ = *frame_row++; \
725 *accum_row++ = *frame_row++; \
726 *accum_row++ = *frame_row++; \
727 if(components == 4) *accum_row++ = *frame_row++; \
731 accum_row += components; \
732 frame_row += components; \
738 if(config.mode == TimeAvgConfig::LESS) \
740 for(int i = 0; i < h; i++) \
742 accum_type *accum_row = (accum_type*)accumulation + \
743 i * w * components; \
744 type *frame_row = (type*)frame->get_rows()[i]; \
745 for(int j = 0; j < w; j++) \
748 /* Compare alpha if 4 channel */ \
749 if(components == 4) \
751 if(frame_row[3] < accum_row[3]) copy_it = 1; \
756 /* Compare YUV luma if 3 channel */ \
757 if(frame_row[0] < accum_row[0]) copy_it = 1; \
761 /* Compare RGB luma if 3 channel */ \
762 if(RGB_TO_VALUE(frame_row[0], frame_row[1], frame_row[2]) < \
763 RGB_TO_VALUE(accum_row[0], accum_row[1], accum_row[2])) \
769 *accum_row++ = *frame_row++; \
770 *accum_row++ = *frame_row++; \
771 *accum_row++ = *frame_row++; \
772 if(components == 4) *accum_row++ = *frame_row++; \
776 accum_row += components; \
777 frame_row += components; \
784 for(int i = 0; i < h; i++) \
786 accum_type *accum_row = (accum_type*)accumulation + \
787 i * w * components; \
788 type *frame_row = (type*)frame->get_rows()[i]; \
789 for(int j = 0; j < w; j++) \
791 *accum_row++ += *frame_row++; \
792 *accum_row++ += (accum_type)*frame_row++ - chroma; \
793 *accum_row++ += (accum_type)*frame_row++ - chroma; \
794 if(components == 4) *accum_row++ += *frame_row++; \
801 void TimeAvgMain::add_accum(VFrame *frame)
803 int w = frame->get_w();
804 int h = frame->get_h();
806 switch(frame->get_color_model())
809 ADD_ACCUM(unsigned char, int, 3, 0x0, 0xff)
812 ADD_ACCUM(float, float, 3, 0x0, 1.0)
815 ADD_ACCUM(unsigned char, int, 4, 0x0, 0xff)
818 ADD_ACCUM(float, float, 4, 0x0, 1.0)
821 ADD_ACCUM(unsigned char, int, 3, 0x80, 0xff)
824 ADD_ACCUM(unsigned char, int, 4, 0x80, 0xff)
827 ADD_ACCUM(uint16_t, int, 3, 0x8000, 0xffff)
829 case BC_YUVA16161616:
830 ADD_ACCUM(uint16_t, int, 4, 0x8000, 0xffff)
835 #define TRANSFER_ACCUM(type, accum_type, components, chroma, max) \
837 if(config.mode == TimeAvgConfig::AVERAGE) \
839 accum_type denominator = config.frames; \
840 for(int i = 0; i < h; i++) \
842 accum_type *accum_row = (accum_type*)accumulation + \
843 i * w * components; \
844 type *frame_row = (type*)frame->get_rows()[i]; \
845 for(int j = 0; j < w; j++) \
847 *frame_row++ = *accum_row++ / denominator; \
848 *frame_row++ = (*accum_row++ - chroma) / denominator + chroma; \
849 *frame_row++ = (*accum_row++ - chroma) / denominator + chroma; \
850 if(components == 4) *frame_row++ = *accum_row++ / denominator; \
855 /* Rescan history every time for these modes */ \
856 if(!config.nosubtract && config.mode == TimeAvgConfig::GREATER) \
858 frame->copy_from(history[0]); \
859 for(int k = 1; k < config.frames; k++) \
861 VFrame *history_frame = history[k]; \
863 for(int i = 0; i < h; i++) \
865 type *history_row = (type*)history_frame->get_rows()[i]; \
866 type *frame_row = (type*)frame->get_rows()[i]; \
868 for(int j = 0; j < w; j++) \
871 /* Compare alpha if 4 channel */ \
872 if(components == 4) \
874 if(history_row[3] > frame_row[3]) copy_it = 1; \
879 /* Compare YUV luma if 3 channel */ \
880 if(history_row[0] > frame_row[0]) copy_it = 1; \
884 /* Compare RGB luma if 3 channel */ \
885 if(RGB_TO_VALUE(history_row[0], history_row[1], history_row[2]) > \
886 RGB_TO_VALUE(frame_row[0], frame_row[1], frame_row[2])) \
892 *frame_row++ = *history_row++; \
893 *frame_row++ = *history_row++; \
894 *frame_row++ = *history_row++; \
895 if(components == 4) *frame_row++ = *history_row++; \
899 frame_row += components; \
900 history_row += components; \
907 if(!config.nosubtract && config.mode == TimeAvgConfig::LESS) \
909 frame->copy_from(history[0]); \
910 for(int k = 1; k < config.frames; k++) \
912 VFrame *history_frame = history[k]; \
914 for(int i = 0; i < h; i++) \
916 type *history_row = (type*)history_frame->get_rows()[i]; \
917 type *frame_row = (type*)frame->get_rows()[i]; \
919 for(int j = 0; j < w; j++) \
922 /* Compare alpha if 4 channel */ \
923 if(components == 4) \
925 if(history_row[3] < frame_row[3]) copy_it = 1; \
930 /* Compare YUV luma if 3 channel */ \
931 if(history_row[0] < frame_row[0]) copy_it = 1; \
935 /* Compare RGB luma if 3 channel */ \
936 if(RGB_TO_VALUE(history_row[0], history_row[1], history_row[2]) < \
937 RGB_TO_VALUE(frame_row[0], frame_row[1], frame_row[2])) \
943 *frame_row++ = *history_row++; \
944 *frame_row++ = *history_row++; \
945 *frame_row++ = *history_row++; \
946 if(components == 4) *frame_row++ = *history_row++; \
950 frame_row += components; \
951 history_row += components; \
959 for(int i = 0; i < h; i++) \
961 accum_type *accum_row = (accum_type*)accumulation + \
962 i * w * components; \
963 type *frame_row = (type*)frame->get_rows()[i]; \
964 for(int j = 0; j < w; j++) \
966 *frame_row++ = *accum_row++; \
967 *frame_row++ = *accum_row++; \
968 *frame_row++ = *accum_row++; \
969 if(components == 4) *frame_row++ = *accum_row++; \
976 void TimeAvgMain::transfer_accum(VFrame *frame)
978 int w = frame->get_w();
979 int h = frame->get_h();
981 switch(frame->get_color_model())
984 TRANSFER_ACCUM(unsigned char, int, 3, 0x0, 0xff)
987 TRANSFER_ACCUM(float, float, 3, 0x0, 1)
990 TRANSFER_ACCUM(unsigned char, int, 4, 0x0, 0xff)
993 TRANSFER_ACCUM(float, float, 4, 0x0, 1)
996 TRANSFER_ACCUM(unsigned char, int, 3, 0x80, 0xff)
999 TRANSFER_ACCUM(unsigned char, int, 4, 0x80, 0xff)
1002 TRANSFER_ACCUM(uint16_t, int, 3, 0x8000, 0xffff)
1004 case BC_YUVA16161616:
1005 TRANSFER_ACCUM(uint16_t, int, 4, 0x8000, 0xffff)
1012 int TimeAvgMain::load_configuration()
1014 KeyFrame *prev_keyframe;
1015 TimeAvgConfig old_config;
1016 old_config.copy_from(&config);
1018 prev_keyframe = get_prev_keyframe(get_source_position());
1019 read_data(prev_keyframe);
1020 return !old_config.equivalent(&config);
1023 void TimeAvgMain::save_data(KeyFrame *keyframe)
1027 // cause data to be stored directly in text
1028 output.set_shared_output(keyframe->get_data(), MESSAGESIZE);
1029 output.tag.set_title("TIME_AVERAGE");
1030 output.tag.set_property("FRAMES", config.frames);
1031 output.tag.set_property("MODE", config.mode);
1032 output.tag.set_property("PARANOID", config.paranoid);
1033 output.tag.set_property("NOSUBTRACT", config.nosubtract);
1034 output.tag.set_property("THRESHOLD", config.threshold);
1035 output.tag.set_property("BORDER", config.border);
1036 output.append_tag();
1037 output.terminate_string();
1040 void TimeAvgMain::read_data(KeyFrame *keyframe)
1044 input.set_shared_input(keyframe->get_data(), strlen(keyframe->get_data()));
1046 while(!input.read_tag())
1048 if(input.tag.title_is("TIME_AVERAGE"))
1050 config.frames = input.tag.get_property("FRAMES", config.frames);
1051 config.mode = input.tag.get_property("MODE", config.mode);
1052 config.paranoid = input.tag.get_property("PARANOID", config.paranoid);
1053 config.nosubtract = input.tag.get_property("NOSUBTRACT", config.nosubtract);
1054 config.threshold = input.tag.get_property("THRESHOLD", config.threshold);
1055 config.border = input.tag.get_property("BORDER", config.border);
1061 void TimeAvgMain::update_gui()
1065 if(load_configuration())
1067 thread->window->lock_window("TimeAvgMain::update_gui");
1068 ((TimeAvgWindow*)thread->window)->total_frames->update(config.frames);
1069 ((TimeAvgWindow*)thread->window)->threshold->update(config.threshold);
1070 ((TimeAvgWindow*)thread->window)->update_toggles();
1071 ((TimeAvgWindow*)thread->window)->paranoid->update(config.paranoid);
1072 ((TimeAvgWindow*)thread->window)->no_subtract->update(config.nosubtract);
1073 ((TimeAvgWindow*)thread->window)->threshold->update(config.threshold);
1074 ((TimeAvgWindow*)thread->window)->border->update(config.border);
1075 thread->window->unlock_window();