4 * Copyright (C) 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
33 #include "bcpbuffer.h"
34 #include "bcresources.h"
35 #include "bcsignals.h"
36 #include "bcsynchronous.h"
37 #include "bctexture.h"
38 #include "bcwindowbase.h"
40 #include "bccmodels.h"
46 static void png_read_function(png_structp png_ptr,
47 png_bytep data, png_size_t length)
49 VFrame *frame = (VFrame*)png_get_io_ptr(png_ptr);
50 if(frame->image_size - frame->image_offset < (long)length)
52 printf("PngReadFunction::png_read_function %d: overrun\n", __LINE__);
53 length = frame->image_size - frame->image_offset;
56 memcpy(data, &frame->image[frame->image_offset], length);
57 frame->image_offset += length;
67 VFrameScene::VFrameScene()
71 VFrameScene::~VFrameScene()
81 //static BCCounter counter;
83 VFramePng::VFramePng(unsigned char *png_data, double s)
86 ((long)png_data[0] << 24) | ((long)png_data[1] << 16) |
87 ((long)png_data[2] << 8) | (long)png_data[3];
88 if( !s ) s = BC_WindowBase::get_resources()->icon_scale;
89 read_png(png_data+4, image_size, s, s);
92 VFramePng::VFramePng(unsigned char *png_data, long image_size, double xs, double ys)
94 if( !xs ) xs = BC_WindowBase::get_resources()->icon_scale;
95 if( !ys ) ys = BC_WindowBase::get_resources()->icon_scale;
96 read_png(png_data, image_size, xs, ys);
99 VFramePng::~VFramePng()
103 VFrame *VFramePng::vframe_png(int fd, double xs, double ys)
106 if( fstat(fd, &st) ) return 0;
107 long len = st.st_size;
110 unsigned char *bfr = (unsigned char *)
111 ::mmap (NULL, len, PROT_READ, MAP_SHARED, fd, 0);
112 if( bfr == MAP_FAILED ) return 0;
113 VFrame *vframe = new VFramePng(bfr, len, xs, ys);
114 if( (w=vframe->get_w()) <= 0 || (h=vframe->get_h()) <= 0 ||
115 vframe->get_data() == 0 ) { delete vframe; vframe = 0; }
119 VFrame *VFramePng::vframe_png(const char *png_path, double xs, double ys)
122 int fd = ::open(png_path, O_RDONLY);
124 vframe = vframe_png(fd, xs, ys);
130 VFrame::VFrame(VFrame &frame)
133 params = new BC_Hash;
134 use_shm = frame.use_shm;
135 allocate_data(0, -1, 0, 0, 0, frame.w, frame.h,
136 frame.color_model, frame.bytes_per_line);
141 VFrame::VFrame(int w, int h, int color_model, long bytes_per_line)
144 // use bytes_per_line == 0 to allocate default unshared
145 if( !bytes_per_line ) { bytes_per_line = -1; use_shm = 0; }
146 params = new BC_Hash;
147 allocate_data(data, -1, 0, 0, 0, w, h,
148 color_model, bytes_per_line);
151 VFrame::VFrame(unsigned char *data, int shmid, int w, int h,
152 int color_model, long bytes_per_line)
155 params = new BC_Hash;
156 allocate_data(data, shmid, 0, 0, 0, w, h,
157 color_model, bytes_per_line);
160 VFrame::VFrame(unsigned char *data, int shmid,
161 long y_offset, long u_offset, long v_offset,
162 int w, int h, int color_model, long bytes_per_line)
165 params = new BC_Hash;
166 allocate_data(data, shmid, y_offset, u_offset, v_offset, w, h,
167 color_model, bytes_per_line);
170 VFrame::VFrame(BC_Bitmap *bitmap, int w, int h,
171 int color_model, long bytes_per_line)
174 params = new BC_Hash;
176 unsigned char *data = 0;
177 if( bitmap->is_shared() )
178 shmid = bitmap->get_shmid();
180 data = bitmap->get_data();
181 allocate_data(data, shmid,
182 bitmap->get_y_offset(),
183 bitmap->get_u_offset(),
184 bitmap->get_v_offset(),
185 w, h, color_model, bytes_per_line);
191 params = new BC_Hash;
192 this->color_model = BC_COMPRESSED;
200 // Delete effect stack
201 prev_effects.remove_all_objects();
202 next_effects.remove_all_objects();
207 int VFrame::equivalent(VFrame *src, int test_stacks)
209 return (src->get_color_model() == get_color_model() &&
210 src->get_w() == get_w() &&
211 src->get_h() == get_h() &&
212 src->bytes_per_line == bytes_per_line &&
213 (!test_stacks || equal_stacks(src)));
216 int VFrame::data_matches(VFrame *frame)
218 if(data && frame->get_data() &&
219 frame->params_match(get_w(), get_h(), get_color_model()) &&
220 get_data_size() == frame->get_data_size())
222 int data_size = get_data_size();
223 unsigned char *ptr1 = get_data();
224 unsigned char *ptr2 = frame->get_data();
225 for(int i = 0; i < data_size; i++)
227 if(*ptr1++ != *ptr2++) return 0;
234 // long VFrame::set_shm_offset(long offset)
236 // shm_offset = offset;
240 // long VFrame::get_shm_offset()
242 // return shm_offset;
245 int VFrame::get_memory_type()
250 int VFrame::params_match(int w, int h, int color_model)
252 return (this->w == w &&
254 this->color_model == color_model);
258 int VFrame::reset_parameters(int do_opengl)
263 memory_type = VFrame::PRIVATE;
271 compressed_allocated = 0;
272 compressed_size = 0; // Size of current image
279 sequence_number = -1;
282 pixel_rgb = 0x000000; // BLACK
283 pixel_yuv = 0x008080;
288 // By default, anything is going to be done in RAM
289 opengl_state = VFrame::RAM;
294 prev_effects.set_array_delete();
295 next_effects.set_array_delete();
299 int VFrame::clear_objects(int do_opengl)
312 if( memory_type != VFrame::SHARED )
313 printf("==del %p from %p\n", data, __builtin_return_address(0));
319 case VFrame::PRIVATE:
321 // if(this->w * this->h > 1500 * 1100)
322 // printf("VFrame::clear_objects 2 this=%p data=%p\n", this, data);
325 //printf("VFrame::clear_objects %d this=%p shmid=%p data=%p\n", __LINE__, this, shmid, data);
345 // Delete row pointers
370 int VFrame::get_field2_offset()
372 return field2_offset;
375 int VFrame::set_field2_offset(int value)
377 this->field2_offset = value;
381 void VFrame::set_keyframe(int value)
383 this->is_keyframe = value;
386 int VFrame::get_keyframe()
392 VFrameScene* VFrame::get_scene()
397 int VFrame::calculate_bytes_per_pixel(int color_model)
399 return BC_CModels::calculate_pixelsize(color_model);
402 long VFrame::get_bytes_per_line()
404 return bytes_per_line;
407 long VFrame::get_data_size()
409 return calculate_data_size(w, h, bytes_per_line, color_model) - 4;
412 long VFrame::calculate_data_size(int w, int h, int bytes_per_line, int color_model)
414 return BC_CModels::calculate_datasize(w, h, bytes_per_line, color_model);
417 void VFrame::create_row_pointers()
420 switch(color_model) {
422 if( this->v_offset ) break;
425 this->v_offset = sz + w / 4 * h / 4;
431 if( this->v_offset ) break;
434 this->v_offset = sz + sz / 4;
438 if( this->v_offset ) break;
441 this->v_offset = sz + sz / 2;
444 if( this->v_offset ) break;
447 this->v_offset = sz + sz;
450 if( this->v_offset ) break;
452 this->u_offset = sz * sizeof(uint8_t);
453 this->v_offset = 2 * sz * sizeof(uint8_t);
456 if( this->v_offset || a ) break;
457 a = this->data + 3 * sz * sizeof(float);
459 if( this->v_offset ) break;
461 this->u_offset = sz * sizeof(float);
462 this->v_offset = 2 * sz * sizeof(float);
466 rows = new unsigned char*[h];
467 for(int i = 0; i < h; i++)
468 rows[i] = &this->data[i * this->bytes_per_line];
471 y = this->data + this->y_offset;
472 u = this->data + this->u_offset;
473 v = this->data + this->v_offset;
476 int VFrame::allocate_data(unsigned char *data, int shmid,
477 long y_offset, long u_offset, long v_offset, int w, int h,
478 int color_model, long bytes_per_line)
482 this->color_model = color_model;
483 this->bytes_per_pixel = calculate_bytes_per_pixel(color_model);
484 this->y_offset = this->u_offset = this->v_offset = 0;
486 // printf("VFrame::allocate_data %d shmid == 0\n", __LINE__, shmid);
489 this->bytes_per_line = bytes_per_line >= 0 ?
490 bytes_per_line : this->bytes_per_pixel * w;
492 // Allocate data + padding for MMX
494 //printf("VFrame::allocate_data %d %p\n", __LINE__, this->data);
495 memory_type = VFrame::SHARED;
498 this->y_offset = y_offset;
499 this->u_offset = u_offset;
500 this->v_offset = v_offset;
502 else if(shmid >= 0) {
503 memory_type = VFrame::SHMGET;
504 this->data = (unsigned char*)shmat(shmid, NULL, 0);
505 //printf("VFrame::allocate_data %d shmid=%d data=%p\n", __LINE__, shmid, this->data);
507 this->y_offset = y_offset;
508 this->u_offset = u_offset;
509 this->v_offset = v_offset;
512 memory_type = VFrame::PRIVATE;
514 int size = calculate_data_size(this->w, this->h,
515 this->bytes_per_line, this->color_model);
516 if( use_shm && size >= SHM_MIN_SIZE &&
517 BC_WindowBase::get_resources()->use_vframe_shm() ) {
518 this->shmid = shmget(IPC_PRIVATE, size, IPC_CREAT | 0777);
519 if( this->shmid >= 0 ) {
520 this->data = (unsigned char*)shmat(this->shmid, NULL, 0);
521 //printf("VFrame::allocate_data %d %d %d %p\n", __LINE__, size, this->shmid, this->data);
522 // This causes it to automatically delete when the program exits.
523 shmctl(this->shmid, IPC_RMID, 0);
526 printf("VFrame::allocate_data %d could not allocate"
527 " shared memory, %dx%d (model %d) size=0x%08x\n",
528 __LINE__, w, h, color_model, size);
529 BC_Trace::dump_shm_stats(stdout);
532 // Have to use malloc for libpng
534 this->data = (unsigned char *)malloc(size);
538 // if(this->w * this->h > 1500 * 1100)
539 // printf("VFrame::allocate_data 2 this=%p w=%d h=%d this->data=%p\n",
540 // this, this->w, this->h, this->data);
543 printf("VFrame::allocate_data %dx%d: memory exhausted.\n", this->w, this->h);
545 printf("==new %p from %p sz %d\n", this->data, __builtin_return_address(0), size);
548 //printf("VFrame::allocate_data %d %p data=%p %d %d\n", __LINE__, this, this->data, this->w, this->h);
549 //if(size > 1000000) printf("VFrame::allocate_data %d\n", size);
552 // Create row pointers
553 create_row_pointers();
557 void VFrame::set_memory(unsigned char *data,
567 memory_type = VFrame::SHARED;
570 this->y_offset = y_offset;
571 this->u_offset = u_offset;
572 this->v_offset = v_offset;
577 memory_type = VFrame::SHMGET;
578 this->data = (unsigned char*)shmat(shmid, NULL, 0);
582 y = this->data + this->y_offset;
583 u = this->data + this->u_offset;
584 v = this->data + this->v_offset;
586 create_row_pointers();
589 void VFrame::set_memory(BC_Bitmap *bitmap)
592 unsigned char *data = 0;
593 if( bitmap->is_shared() && !bitmap->is_zombie() )
594 shmid = bitmap->get_shmid();
596 data = bitmap->get_data();
597 set_memory(data, shmid,
598 bitmap->get_y_offset(),
599 bitmap->get_u_offset(),
600 bitmap->get_v_offset());
603 void VFrame::set_compressed_memory(unsigned char *data,
612 memory_type = VFrame::SHARED;
619 memory_type = VFrame::SHMGET;
620 this->data = (unsigned char*)shmat(shmid, NULL, 0);
624 this->compressed_allocated = data_allocated;
625 this->compressed_size = data_size;
629 // Reallocate uncompressed buffer with or without alpha
630 int VFrame::reallocate(
641 // if(shmid == 0) printf("VFrame::reallocate %d shmid=%d\n", __LINE__, shmid);
643 // reset_parameters(0);
656 int VFrame::allocate_compressed_data(long bytes)
658 if(bytes < 1) return 1;
660 // Want to preserve original contents
661 if(data && compressed_allocated < bytes)
664 unsigned char *new_data = 0;
665 if(BC_WindowBase::get_resources()->use_vframe_shm() && use_shm)
667 new_shmid = shmget(IPC_PRIVATE,
670 new_data = (unsigned char*)shmat(new_shmid, NULL, 0);
671 shmctl(new_shmid, IPC_RMID, 0);
675 // Have to use malloc for libpng
676 new_data = (unsigned char *)malloc(bytes);
679 bcopy(data, new_data, compressed_allocated);
682 if(memory_type == VFrame::PRIVATE)
692 if(memory_type == VFrame::SHMGET)
700 compressed_allocated = bytes;
705 if(BC_WindowBase::get_resources()->use_vframe_shm() && use_shm)
707 shmid = shmget(IPC_PRIVATE,
710 data = (unsigned char*)shmat(shmid, NULL, 0);
711 shmctl(shmid, IPC_RMID, 0);
715 // Have to use malloc for libpng
716 data = (unsigned char *)malloc(bytes);
719 compressed_allocated = bytes;
726 int VFramePng::read_png(const unsigned char *data, long sz, double xscale, double yscale)
728 // Test for RAW format
729 if(data[0] == 'R' && data[1] == 'A' && data[2] == 'W' && data[3] == ' ') {
730 int new_color_model = BC_RGBA8888;
731 w = data[4] | (data[5] << 8) | (data[6] << 16) | (data[7] << 24);
732 h = data[8] | (data[9] << 8) | (data[10] << 16) | (data[11] << 24);
733 int components = data[12];
734 new_color_model = components == 3 ? BC_RGB888 : BC_RGBA8888;
735 // This shares the data directly
736 // reallocate(data + 20, 0, 0, 0, w, h, new_color_model, -1);
738 // Can't use shared data for theme since button constructions overlay the
740 reallocate(NULL, -1, 0, 0, 0, w, h, new_color_model, -1);
741 memcpy(get_data(), data + 16, w * h * components);
744 else if(data[0] == 0x89 && data[1] == 'P' && data[2] == 'N' && data[3] == 'G') {
746 png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
747 png_infop info_ptr = png_create_info_struct(png_ptr);
751 image = data; image_size = sz;
752 png_set_read_fn(png_ptr, this, PngReadFunction::png_read_function);
753 png_read_info(png_ptr, info_ptr);
755 w = png_get_image_width(png_ptr, info_ptr);
756 h = png_get_image_height(png_ptr, info_ptr);
758 int src_color_model = png_get_color_type(png_ptr, info_ptr);
760 /* tell libpng to strip 16 bit/color files down to 8 bits/color */
761 png_set_strip_16(png_ptr);
763 /* extract multiple pixels with bit depths of 1, 2, and 4 from a single
764 * byte into separate bytes (useful for paletted and grayscale images).
766 png_set_packing(png_ptr);
768 /* expand paletted colors into true RGB triplets */
769 if (src_color_model == PNG_COLOR_TYPE_PALETTE)
770 png_set_expand(png_ptr);
772 /* expand grayscale images to the full 8 bits from 1, 2, or 4 bits/pixel */
773 if (src_color_model == PNG_COLOR_TYPE_GRAY && png_get_bit_depth(png_ptr, info_ptr) < 8)
774 png_set_expand(png_ptr);
776 if (src_color_model == PNG_COLOR_TYPE_GRAY ||
777 src_color_model == PNG_COLOR_TYPE_GRAY_ALPHA)
778 png_set_gray_to_rgb(png_ptr);
780 /* expand paletted or RGB images with transparency to full alpha channels
781 * so the data will be available as RGBA quartets */
782 if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)){
784 png_set_expand(png_ptr);
787 switch(src_color_model)
789 case PNG_COLOR_TYPE_GRAY:
790 case PNG_COLOR_TYPE_RGB:
791 new_color_model = BC_RGB888;
794 case PNG_COLOR_TYPE_GRAY_ALPHA:
795 case PNG_COLOR_TYPE_RGB_ALPHA:
797 new_color_model = BC_RGBA8888;
800 case PNG_COLOR_TYPE_PALETTE:
802 new_color_model = BC_RGBA8888;
804 new_color_model = BC_RGB888;
807 reallocate(NULL, -1, 0, 0, 0, w, h, new_color_model, -1);
809 //printf("VFrame::read_png %d %d %d %p\n", __LINE__, w, h, get_rows());
810 png_read_image(png_ptr, get_rows());
811 png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
814 printf("VFrame::read_png %d: unknown file format"
815 " 0x%02x 0x%02x 0x%02x 0x%02x\n",
816 __LINE__, data[4], data[5], data[6], data[7]);
819 int ww = w * xscale, hh = h * yscale;
820 if( ww != w || hh != h ) {
821 VFrame vframe(*this);
822 reallocate(NULL, -1, 0, 0, 0, ww, hh, color_model, -1);
823 transfer_from(&vframe);
828 int VFrame::write_png(const char *path)
830 VFrame *vframe = this;
831 png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
832 png_infop info_ptr = png_create_info_struct(png_ptr);
833 FILE *out_fd = fopen(path, "w");
835 printf("VFrame::write_png %d %s %s\n", __LINE__, path, strerror(errno));
839 int png_cmodel = PNG_COLOR_TYPE_RGB;
840 int bc_cmodel = get_color_model();
841 switch( bc_cmodel ) {
842 case BC_RGB888: break;
843 case BC_RGBA8888: png_cmodel = PNG_COLOR_TYPE_RGB_ALPHA; break;
844 case BC_A8: png_cmodel = PNG_COLOR_TYPE_GRAY; break;
846 bc_cmodel = BC_RGB888;
847 if( BC_CModels::has_alpha(bc_cmodel) ) {
848 bc_cmodel = BC_RGBA8888;
849 png_cmodel = PNG_COLOR_TYPE_RGB_ALPHA;
851 vframe = new VFrame(get_w(), get_h(), bc_cmodel, 0);
852 vframe->transfer_from(this);
855 png_init_io(png_ptr, out_fd);
856 png_set_compression_level(png_ptr, 9);
857 png_set_IHDR(png_ptr, info_ptr, get_w(), get_h(), 8, png_cmodel,
858 PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
859 png_write_info(png_ptr, info_ptr);
860 png_write_image(png_ptr, vframe->get_rows());
861 png_write_end(png_ptr, info_ptr);
862 png_destroy_write_struct(&png_ptr, &info_ptr);
864 if( vframe != this ) delete vframe;
869 #define ZERO_YUV(components, type, max) \
871 for(int i = 0; i < h; i++) \
873 type *row = (type*)get_rows()[i]; \
874 for(int j = 0; j < w; j++) \
876 row[j * components] = 0; \
877 row[j * components + 1] = (max + 1) / 2; \
878 row[j * components + 2] = (max + 1) / 2; \
879 if(components == 4) row[j * components + 3] = 0; \
884 int VFrame::clear_frame()
887 //printf("VFrame::clear_frame %d\n", __LINE__);
888 switch(color_model) {
894 memset(get_u(), 0x80, w / 4 * h / 4);
895 memset(get_v(), 0x80, w / 4 * h / 4);
902 memset(get_u(), 0x80, sz / 4);
903 memset(get_v(), 0x80, sz / 4);
908 memset(get_u(), 0x80, sz / 2);
909 memset(get_v(), 0x80, sz / 2);
918 case BC_RGBA_FLOATP: if( a ) {
919 float *ap = (float *)a;
920 for( int i=sz; --i>=0; ++ap ) *ap = 0.f; }
921 case BC_RGB_FLOATP: {
922 float *rp = (float *)y;
923 for( int i=sz; --i>=0; ++rp ) *rp = 0.f;
924 float *gp = (float *)u;
925 for( int i=sz; --i>=0; ++gp ) *gp = 0.f;
926 float *bp = (float *)v;
927 for( int i=sz; --i>=0; ++bp ) *bp = 0.f;
931 memset(get_u(), 0x80, sz);
932 memset(get_v(), 0x80, sz);
936 ZERO_YUV(3, unsigned char, 0xff);
940 ZERO_YUV(4, unsigned char, 0xff);
944 ZERO_YUV(3, uint16_t, 0xffff);
947 case BC_YUVA16161616:
948 ZERO_YUV(4, uint16_t, 0xffff);
952 bzero(data, calculate_data_size(w, h, bytes_per_line, color_model));
958 void VFrame::rotate90()
960 // Allocate new frame
961 int new_w = h, new_h = w;
962 VFrame new_frame(new_w, new_h, color_model);
963 unsigned char **new_rows = new_frame.get_rows();
965 for(int in_y = 0, out_x = new_w - 1; in_y < h; in_y++, out_x--)
967 for(int in_x = 0, out_y = 0; in_x < w; in_x++, out_y++)
969 for(int k = 0; k < bytes_per_pixel; k++)
971 new_rows[out_y][out_x * bytes_per_pixel + k] =
972 rows[in_y][in_x * bytes_per_pixel + k];
979 unsigned char *new_data = new_frame.data;
980 new_frame.data = data;
983 new_rows = new_frame.rows;
984 new_frame.rows = rows;
987 int new_shmid = new_frame.shmid;
988 new_frame.shmid = shmid;
990 // swap bytes_per_line
991 int new_bpl = new_frame.bytes_per_line;
992 new_frame.bytes_per_line = bytes_per_line;
993 bytes_per_line = new_bpl;
994 new_frame.clear_objects(0);
1000 void VFrame::rotate270()
1002 // Allocate new frame
1003 int new_w = h, new_h = w;
1004 VFrame new_frame(new_w, new_h, color_model);
1005 unsigned char **new_rows = new_frame.get_rows();
1007 for(int in_y = 0, out_x = 0; in_y < h; in_y++, out_x++)
1009 for(int in_x = 0, out_y = new_h - 1; in_x < w; in_x++, out_y--)
1011 for(int k = 0; k < bytes_per_pixel; k++)
1013 new_rows[out_y][out_x * bytes_per_pixel + k] =
1014 rows[in_y][in_x * bytes_per_pixel + k];
1021 unsigned char *new_data = new_frame.data;
1022 new_frame.data = data;
1025 new_rows = new_frame.rows;
1026 new_frame.rows = rows;
1029 int new_shmid = new_frame.shmid;
1030 new_frame.shmid = shmid;
1032 // swap bytes_per_line
1033 int new_bpl = new_frame.bytes_per_line;
1034 new_frame.bytes_per_line = bytes_per_line;
1035 bytes_per_line = new_bpl;
1036 new_frame.clear_objects(0);
1042 void VFrame::flip_vert()
1044 unsigned char temp[bytes_per_line];
1045 for( int i=0, j=h; --j>i; ++i ) {
1046 memcpy(temp, rows[j], bytes_per_line);
1047 memcpy(rows[j], rows[i], bytes_per_line);
1048 memcpy(rows[i], temp, bytes_per_line);
1052 void VFrame::flip_horiz()
1054 unsigned char temp[32];
1055 for(int i = 0; i < h; i++)
1057 unsigned char *row = rows[i];
1058 for(int j = 0; j < bytes_per_line / 2; j += bytes_per_pixel)
1060 memcpy(temp, row + j, bytes_per_pixel);
1061 memcpy(row + j, row + bytes_per_line - j - bytes_per_pixel, bytes_per_pixel);
1062 memcpy(row + bytes_per_line - j - bytes_per_pixel, temp, bytes_per_pixel);
1069 int VFrame::copy_from(VFrame *frame)
1071 if(this->w != frame->get_w() ||
1072 this->h != frame->get_h())
1074 printf("VFrame::copy_from %d sizes differ src %dx%d != dst %dx%d\n",
1083 int w = MIN(this->w, frame->get_w());
1084 int h = MIN(this->h, frame->get_h());
1085 timestamp = frame->timestamp;
1087 switch(frame->color_model)
1090 allocate_compressed_data(frame->compressed_size);
1091 memcpy(data, frame->data, frame->compressed_size);
1092 this->compressed_size = frame->compressed_size;
1096 memcpy(get_y(), frame->get_y(), w * h);
1097 memcpy(get_u(), frame->get_u(), w / 4 * h / 4);
1098 memcpy(get_v(), frame->get_v(), w / 4 * h / 4);
1104 //printf("%d %d %p %p %p %p %p %p\n", w, h, get_y(), get_u(), get_v(), frame->get_y(), frame->get_u(), frame->get_v());
1105 memcpy(get_y(), frame->get_y(), w * h);
1106 memcpy(get_u(), frame->get_u(), w * h / 4);
1107 memcpy(get_v(), frame->get_v(), w * h / 4);
1111 //printf("%d %d %p %p %p %p %p %p\n", w, h, get_y(), get_u(), get_v(), frame->get_y(), frame->get_u(), frame->get_v());
1112 memcpy(get_y(), frame->get_y(), w * h);
1113 memcpy(get_u(), frame->get_u(), w * h / 2);
1114 memcpy(get_v(), frame->get_v(), w * h / 2);
1118 //printf("%d %d %p %p %p %p %p %p\n", w, h, get_y(), get_u(), get_v(), frame->get_y(), frame->get_u(), frame->get_v());
1119 memcpy(get_y(), frame->get_y(), w * h);
1120 memcpy(get_u(), frame->get_u(), w * h);
1121 memcpy(get_v(), frame->get_v(), w * h);
1124 // printf("VFrame::copy_from %d\n", calculate_data_size(w,
1127 // frame->color_model));
1128 // Copy without extra 4 bytes in case the source is a hardware device
1129 memmove(data, frame->data, get_data_size());
1136 int VFrame::transfer_from(VFrame *that, int bg_color, int in_x, int in_y, int in_w, int in_h)
1138 timestamp = that->timestamp;
1141 if( this->get_color_model() == that->get_color_model() &&
1142 this->get_w() == that->get_w() && this->get_h() == that->get_h() &&
1143 this->get_bytes_per_line() == that->get_bytes_per_line() )
1144 return this->copy_from(that);
1147 BC_CModels::transfer(
1148 this->get_rows(), that->get_rows(), // Packed data out/in
1149 this->get_y(), this->get_u(), this->get_v(), // Planar data out/in
1150 that->get_y(), that->get_u(), that->get_v(),
1151 0, 0, that->get_w(), that->get_h(), // Dimensions in/out
1152 0, 0, this->get_w(), this->get_h(),
1153 that->get_color_model(), this->get_color_model(), // Color models in/out
1154 bg_color, // alpha blend bg_color
1155 that->get_bytes_per_line(),
1156 this->get_bytes_per_line()); // rowspans (of luma for YUV)
1158 unsigned char *in_ptrs[4], *out_ptrs[4];
1159 unsigned char **inp, **outp;
1160 if( BC_CModels::is_planar(that->get_color_model()) ) {
1161 in_ptrs[0] = that->get_y();
1162 in_ptrs[1] = that->get_u();
1163 in_ptrs[2] = that->get_v();
1164 in_ptrs[3] = that->get_a();
1168 inp = that->get_rows();
1169 if( BC_CModels::is_planar(this->get_color_model()) ) {
1170 out_ptrs[0] = this->get_y();
1171 out_ptrs[1] = this->get_u();
1172 out_ptrs[2] = this->get_v();
1173 out_ptrs[3] = this->get_a();
1177 outp = this->get_rows();
1178 BC_CModels::transfer(outp, this->get_color_model(),
1179 0, 0, this->get_w(), this->get_h(),
1180 this->get_bytes_per_line(),
1181 inp, that->get_color_model(),
1182 in_x, in_y, in_w, in_h,
1183 that->get_bytes_per_line(),
1190 int VFrame::get_scale_tables(int *column_table, int *row_table,
1191 int in_x1, int in_y1, int in_x2, int in_y2,
1192 int out_x1, int out_y1, int out_x2, int out_y2)
1195 float w_in = in_x2 - in_x1;
1196 float h_in = in_y2 - in_y1;
1197 int w_out = out_x2 - out_x1;
1198 int h_out = out_y2 - out_y1;
1200 float hscale = w_in / w_out;
1201 float vscale = h_in / h_out;
1203 for(i = 0; i < w_out; i++)
1205 column_table[i] = (int)(hscale * i);
1208 for(i = 0; i < h_out; i++)
1210 row_table[i] = (int)(vscale * i) + in_y1;
1215 void VFrame::push_prev_effect(const char *name)
1218 prev_effects.append(ptr = new char[strlen(name) + 1]);
1220 if(prev_effects.total > MAX_STACK_ELEMENTS) prev_effects.remove_object(0);
1223 void VFrame::pop_prev_effect()
1225 if(prev_effects.total)
1226 prev_effects.remove_object(prev_effects.last());
1229 void VFrame::push_next_effect(const char *name)
1232 next_effects.append(ptr = new char[strlen(name) + 1]);
1234 if(next_effects.total > MAX_STACK_ELEMENTS) next_effects.remove_object(0);
1237 void VFrame::pop_next_effect()
1239 if(next_effects.total)
1240 next_effects.remove_object(next_effects.last());
1243 const char* VFrame::get_next_effect(int number)
1245 if(!next_effects.total) return "";
1247 if(number > next_effects.total - 1) number = next_effects.total - 1;
1249 return next_effects.values[next_effects.total - number - 1];
1252 const char* VFrame::get_prev_effect(int number)
1254 if(!prev_effects.total) return "";
1256 if(number > prev_effects.total - 1) number = prev_effects.total - 1;
1258 return prev_effects.values[prev_effects.total - number - 1];
1261 BC_Hash* VFrame::get_params()
1266 void VFrame::clear_stacks()
1268 next_effects.remove_all_objects();
1269 prev_effects.remove_all_objects();
1274 void VFrame::copy_params(VFrame *src)
1276 status = src->status;
1277 params->copy_from(src->params);
1280 void VFrame::copy_stacks(VFrame *src)
1284 for( int i=0; i < src->next_effects.total; ++i )
1285 next_effects.append(cstrdup(src->next_effects[i]));
1286 for( int i=0; i < src->prev_effects.total; ++i )
1287 prev_effects.append(cstrdup(src->prev_effects[i]));
1292 int VFrame::copy_vframe(VFrame *frame)
1295 return copy_from(frame);
1298 int VFrame::equal_stacks(VFrame *src)
1300 for(int i = 0; i < src->next_effects.total && i < next_effects.total; i++)
1302 if(strcmp(src->next_effects.values[i], next_effects.values[i])) return 0;
1305 for(int i = 0; i < src->prev_effects.total && i < prev_effects.total; i++)
1307 if(strcmp(src->prev_effects.values[i], prev_effects.values[i])) return 0;
1310 if(!params->equivalent(src->params)) return 0;
1314 void VFrame::dump_stacks()
1316 printf("VFrame::dump_stacks\n");
1317 printf(" next_effects:\n");
1318 for(int i = next_effects.total - 1; i >= 0; i--)
1319 printf(" %s\n", next_effects.values[i]);
1320 printf(" prev_effects:\n");
1321 for(int i = prev_effects.total - 1; i >= 0; i--)
1322 printf(" %s\n", prev_effects.values[i]);
1325 void VFrame::dump_params()
1332 printf("VFrame::dump %d this=%p\n", __LINE__, this);
1333 printf(" w=%d h=%d colormodel=%d rows=%p use_shm=%d shmid=%d\n",
1334 w, h, color_model, rows, use_shm, shmid);
1338 int VFrame::get_memory_usage()
1340 if(get_compressed_allocated()) return get_compressed_allocated();
1341 return get_h() * get_bytes_per_line();
1344 void VFrame::set_pixel_color(int rgb)
1347 int ir = 0xff & (pixel_rgb >> 16);
1348 int ig = 0xff & (pixel_rgb >> 8);
1349 int ib = 0xff & (pixel_rgb >> 0);
1350 YUV::yuv.rgb_to_yuv_8(ir, ig, ib);
1351 pixel_yuv = (ir<<16) | (ig<<8) | (ib<<0);
1354 void VFrame::set_stiple(int mask)
1359 int VFrame::draw_pixel(int x, int y)
1361 if( x < 0 || y < 0 || x >= get_w() || y >= get_h() ) return 1;
1363 #define DRAW_PIXEL(type, r, g, b) { \
1364 type **rows = (type**)get_rows(); \
1365 rows[y][x * components + 0] = r; \
1366 rows[y][x * components + 1] = g; \
1367 rows[y][x * components + 2] = b; \
1368 if( components == 4 ) \
1369 rows[y][x * components + 3] = mx; \
1371 int components = BC_CModels::components(color_model);
1372 int bch = BC_CModels::calculate_pixelsize(color_model) / components;
1373 int sz = 8*bch, mx = BC_CModels::is_float(color_model) ? 1 : (1<<sz)-1;
1374 int is_yuv = BC_CModels::is_yuv(color_model);
1375 int pixel_color = is_yuv ? pixel_yuv : pixel_rgb;
1376 int ir = 0xff & (pixel_color >> 16); float fr = 0;
1377 int ig = 0xff & (pixel_color >> 8); float fg = 0;
1378 int ib = 0xff & (pixel_color >> 0); float fb = 0;
1379 if( (x+y) & stipple ) {
1380 ir = 255 - ir; ig = 255 - ig; ib = 255 - ib;
1382 if( BC_CModels::is_float(color_model) ) {
1383 fr = ir / 255.; fg = ig / 255.; fb = ib / 255.;
1386 else if( (sz-=8) > 0 ) {
1387 ir <<= sz; ig <<= sz; ib <<= sz;
1390 switch(get_color_model()) {
1395 DRAW_PIXEL(uint8_t, ir, ig, ib);
1399 case BC_RGBA16161616:
1400 case BC_YUVA16161616:
1401 DRAW_PIXEL(uint16_t, ir, ig, ib);
1405 DRAW_PIXEL(float, fr, fg, fb);
1413 void VFrame::draw_line(int x1, int y1, int x2, int y2)
1416 int tx = x1; x1 = x2; x2 = tx;
1417 int ty = y1; y1 = y2; y2 = ty;
1421 int dx = x2-x1, dy = y2-y1;
1422 int dx2 = 2*dx, dy2 = 2*dy;
1423 if( dx < 0 ) dx = -dx;
1424 int r = dx > dy ? dx : dy, n = r;
1426 if( dx2 < 0 ) dir += 1;
1428 if( dx2 >= 0 ) do { /* +Y, +X */
1430 if( (r -= dx2) < 0 ) { r += dy2; ++x; }
1431 } while( --n >= 0 );
1432 else do { /* +Y, -X */
1434 if( (r += dx2) < 0 ) { r += dy2; --x; }
1435 } while( --n >= 0 );
1438 if( dx2 >= 0 ) do { /* +X, +Y */
1440 if( (r -= dy2) < 0 ) { r += dx2; ++y; }
1441 } while( --n >= 0 );
1442 else do { /* -X, +Y */
1444 if( (r -= dy2) < 0 ) { r -= dx2; ++y; }
1445 } while( --n >= 0 );
1449 // g++ -dD -E - < /dev/null | grep DBL_EPSILON
1450 #ifndef __DBL_EPSILON__
1451 #define __DBL_EPSILON__ ((double)2.22044604925031308085e-16L)
1453 // weakest fraction * graphics integer range
1454 #define RND_EPSILON (__DBL_EPSILON__*65536)
1457 int rnd(double v) { return round(v)+RND_EPSILON; }
1460 int sx, sy, ex, ey; /* current point, end point */
1461 int xs, ys; /* x/y quadrant sign -1/1 */
1462 int64_t A, B, C; /* quadratic coefficients */
1463 int64_t r, dx, dy; /* residual, dr/dx and dr/dy */
1464 int xmxx, xmxy; /* x,y at apex */
1467 void init0(int x1,int y1, int x2,int y2, int x3,int y3, int top);
1468 void init1(int x1,int y1, int x2,int y2, int x3,int y3);
1469 int64_t rx() { return r + xs*8*dx + 4*A; }
1470 void moveX(int64_t r) {
1471 dx += xs*A; dy -= xs*B;
1472 this->r = r; sx += xs;
1474 int64_t ry() { return r + 8*dy + 4*C; }
1475 void moveY(int64_t r) {
1481 smooth_line(VFrame *vframe) { this->vframe = vframe; this->done = 0; }
1485 void smooth_line::draw()
1488 if( abs(dy) >= abs(dx) ) {
1489 if( xs*(sx-xmxx) >= 0 ) {
1490 if( ys > 0 ) { done = 1; return; }
1491 if( dy < 0 || ry() < 0 ) { moveY(ry()); goto xit; }
1492 xmxx = ex; xmxy = ey;
1497 if( abs(rr) < abs(r) )
1502 if( ys > 0 ) { done = 1; return; }
1503 xmxx = ex; xmxy = ey;
1508 if( abs(rr) < abs(r) )
1511 xit: vframe->draw_pixel(sx, sy);
1514 void VFrame::draw_smooth(int x1, int y1, int x2, int y2, int x3, int y3)
1516 if( (x1 == x2 && y1 == y2) || (x2 == x3 && y2 == y3) )
1517 draw_line(x1,y1, x3,y3);
1518 else if( x1 == x3 && y1 == y3 )
1519 draw_line(x1,y1, x2,y2);
1520 else if( (x2-x1) * (y2-y3) == (x2-x3) * (y2-y1) ) {
1521 // co-linear, draw line from min to max
1523 if( x2 < x1 ) { x1 = x2; y1 = y2; }
1524 if( x2 > x3 ) { x3 = x2; y3 = y2; }
1527 if( x2 > x1 ) { x1 = x2; y1 = y2; }
1528 if( x2 < x3 ) { x3 = x2; y3 = y2; }
1530 draw_line(x1,y1, x3,y3);
1533 smooth_draw(x1, y1, x2, y2, x3, y3);
1537 Non-Parametric Smooth Curve Generation. Don Kelly 1984
1544 Let the starting point be P. the ending point R. and the tangent vertex Q.
1545 A general point Z on the curve is then
1546 Z = (P + R - Q) + (Q - P) sin t + (Q - R) cos t
1548 Expanding the Cartesian coordinates around (P + R - Q) gives
1549 [x y] = Z - (P + R - Q)
1552 x = a*sin(t) + b*cos(t)
1553 y = c*sin(t) + d*cos(t)
1555 from which t can now be eliminated via
1556 c*x - a*y = (c*b - a*d)*cos(t)
1557 d*x - b*y = (a*d - c*b)*sin(t)
1559 giving the Cartesian equation for the ellipse as
1560 f(x, y) = (c*x - a*y)**2 + (d*x - b*y)**2 - (a*d - c*b)**2 = 0
1562 or: f(x, y) = A*x**2 - 2*B*x*y + C*y**2 + B**2 - A*C = 0
1563 where: A = c**2 + d**2, B = a*c + b*d, C = a**2 + b**2
1565 The maximum y extent of the ellipse may now be derived as follows:
1566 let df/dx = 0, 2*A*x = 2*B*y, x = y*B/A
1567 f(x, y) == B**2 * y**2 / A - 2*B**2 * y**2 / A + C*y**2 + B**2 - A*C = 0
1568 (A*C - B**2)*y = (A*C - B**2)*A
1569 max x = sqrt(C), at y = B/sqrt(C)
1570 max y = sqrt(A), at x = B/sqrt(A)
1575 /* x1,y1 = P, x2,y2 = Q, x3,y3=R,
1576 * draw from P to Q to R if top=0
1577 * or from P to (x,ymax) if top>0
1578 * or from Q to (x,ymax) if top<0
1580 void smooth_line::init0(int x1,int y1, int x2,int y2, int x3,int y3, int top)
1582 int x0 = x1+x3-x2, y0 = y1+y3-y2; // Q'
1584 int a = x2-x1, c = y2-y1;
1585 int b = x2-x3, d = y2-y3;
1586 A = c*c + d*d; C = a*a + b*b; B = a*c + b*d;
1588 sx = top >= 0 ? x1 : x3;
1589 sy = top >= 0 ? y1 : y3;
1590 xs = x2 > sx || (x2==sx && (x1+x3-sx)>=x2) ? 1 : -1;
1591 int64_t px = sx-x0, py = sy-y0;
1592 dx = A*px - B*py; dy = C*py - B*px;
1596 double ymy = sqrt(A), ymx = B/ymy;
1604 ys = a*b > 0 && (!top || top*xs*(b*c - a*d) > 0) ? -1 : 1;
1606 double xmx = xs*sqrt(C), xmy = B/xmx;
1607 xmxx = x0 + rnd(xmx);
1608 xmxy = y0 + rnd(xmy);
1611 xmxx = ex; xmxy = ey;
1615 /* x1,y1 = P, x2,y2 = Q, x3,y3=R,
1616 * draw from (x,ymax) to P
1618 void smooth_line::init1(int x1,int y1, int x2,int y2, int x3,int y3)
1620 int x0 = x1+x3-x2, y0 = y1+y3-y2; // Q'
1622 int a = x2-x1, c = y2-y1;
1623 int b = x2-x3, d = y2-y3;
1624 A = c*c + d*d; C = a*a + b*b; B = a*c + b*d;
1626 double ymy = -sqrt(A), ymx = B/ymy;
1627 int64_t px = rnd(ymx), py = rnd(ymy);
1628 sx = x0 + px; ex = x1;
1629 sy = y0 + py; ey = y1;
1630 xs = x2 > x1 || (x2==x1 && x3>=x2) ? 1 : -1;
1631 dx = A*px - B*py; dy = C*py - B*px;
1632 r = 4 * (A*px*px - 2*B*px*py + C*py*py + B*B - A*C);
1634 ys = a*b > 0 && xs*(b*c - a*d) < 0 ? -1 : 1;
1636 double xmx = xs*sqrt(C), xmy = B/xmx;
1637 xmxx = x0 + rnd(xmx);
1638 xmxy = y0 + rnd(xmy);
1642 xmxx = ex; xmxy = ey;
1645 vframe->draw_pixel(sx, sy);
1646 while( xs*(sx-xmxx) < 0 && (xs*dx < 0 || rx() < 0) ) {
1648 vframe->draw_pixel(sx, sy);
1653 void VFrame::smooth_draw(int x1, int y1, int x2, int y2, int x3, int y3)
1655 //printf("p smooth_draw( %d,%d, %d,%d, %d,%d )\n", x1,y1,x2,y2,x3,y3);
1656 if( y1 > y3 ) { // make y3 >= y1
1657 int xt = x1; x1 = x3; x3 = xt;
1658 int yt = y1; y1 = y3; y3 = yt;
1660 if( y1 > y2 && y3 > y2 ) {
1661 smooth_line lt(this), rt(this); // Q on bottom
1662 lt.init1(x1, y1, x2, y2, x3, y3);
1663 rt.init1(x3, y3, x2, y2, x1, y1);
1664 while( !lt.done || !rt.done ) {
1669 else if( y1 < y2 && y3 < y2 ) {
1670 smooth_line lt(this), rt(this); // Q on top
1671 lt.init0(x1, y1, x2, y2, x3, y3, 1);
1672 draw_pixel(lt.sx, lt.sy);
1673 rt.init0(x1, y1, x2, y2, x3, y3, -1);
1674 draw_pixel(rt.sx, rt.sy);
1675 while( !lt.done || !rt.done ) {
1681 smooth_line pt(this); // Q in between
1682 pt.init0(x1, y1, x2, y2, x3, y3, 0);
1683 draw_pixel(pt.sx, pt.sy);
1691 void VFrame::draw_rect(int x1, int y1, int x2, int y2)
1693 draw_line(x1, y1, x2, y1);
1694 draw_line(x2, y1 + 1, x2, y2);
1695 draw_line(x2 - 1, y2, x1, y2);
1696 draw_line(x1, y2 - 1, x1, y1 + 1);
1700 void VFrame::draw_oval(int x1, int y1, int x2, int y2)
1704 int center_x = (x2 + x1) / 2;
1705 int center_y = (y2 + y1) / 2;
1708 //printf("VFrame::draw_oval %d %d %d %d %d\n", __LINE__, x1, y1, x2, y2);
1710 for(int i = 0; i < h / 2; i++) {
1711 // A^2 = -(B^2) + C^2
1712 x_table[i] = (int)(sqrt(-SQR(h / 2 - i) + SQR(h / 2)) * w / h);
1713 //printf("VFrame::draw_oval %d i=%d x=%d\n", __LINE__, i, x_table[i]);
1716 for(int i = 0; i < h / 2 - 1; i++) {
1717 int x3 = x_table[i];
1718 int x4 = x_table[i + 1];
1721 for(int j = x3; j < x4; j++) {
1722 draw_pixel(center_x + j, y1 + i);
1723 draw_pixel(center_x - j, y1 + i);
1724 draw_pixel(center_x + j, y2 - i - 1);
1725 draw_pixel(center_x - j, y2 - i - 1);
1729 draw_pixel(center_x + x3, y1 + i);
1730 draw_pixel(center_x - x3, y1 + i);
1731 draw_pixel(center_x + x3, y2 - i - 1);
1732 draw_pixel(center_x - x3, y2 - i - 1);
1736 draw_pixel(center_x, y1);
1737 draw_pixel(center_x, y2 - 1);
1738 draw_pixel(x1, center_y);
1739 draw_pixel(x2 - 1, center_y);
1740 draw_pixel(x1, center_y - 1);
1741 draw_pixel(x2 - 1, center_y - 1);
1745 void VFrame::draw_arrow(int x1, int y1, int x2, int y2, int sz)
1747 double angle = atan((float)(y2 - y1) / (float)(x2 - x1));
1748 double angle1 = angle + (float)145 / 360 * 2 * M_PI;
1749 double angle2 = angle - (float)145 / 360 * 2 * M_PI;
1750 int s = x2 < x1 ? -1 : 1;
1751 int x3 = x2 + s * (int)(sz * cos(angle1));
1752 int y3 = y2 + s * (int)(sz * sin(angle1));
1753 int x4 = x2 + s * (int)(sz * cos(angle2));
1754 int y4 = y2 + s * (int)(sz * sin(angle2));
1757 draw_line(x1, y1, x2, y2);
1758 // draw_line(x1, y1 + 1, x2, y2 + 1);
1761 if(abs(y2 - y1) || abs(x2 - x1)) draw_line(x2, y2, x3, y3);
1763 if(abs(y2 - y1) || abs(x2 - x1)) draw_line(x2, y2, x4, y4);
1766 void VFrame::draw_x(int x, int y, int sz)
1768 draw_line(x-sz,y-sz, x+sz,y+sz);
1769 draw_line(x+sz,y-sz, x-sz,y+sz);
1771 void VFrame::draw_t(int x, int y, int sz)
1773 draw_line(x,y-sz, x,y+sz);
1774 draw_line(x+sz,y, x-sz,y);