diff --git a/Demo2.cpp b/Demo2.cpp index 6c114134df1ba91ef369cd2b320d1976d7c83014..2908f040a88cc4fcd0e2e505e1fb18d26aa4ab91 100644 --- a/Demo2.cpp +++ b/Demo2.cpp @@ -15,6 +15,7 @@ based on original demo.cpp //cpp c #include <iostream> #include <algorithm> +#include <vector> #include <cstdlib> #include <stdio.h> /* printf, scanf, puts, NULL */ #include <stdlib.h> /* srand, rand */ @@ -51,6 +52,15 @@ bool cmdOptionExists(char** begin, char** end, const std::string& option) } +static std::vector<char> copy_data(struct archive *aw, unsigned char *buffer); + +static void errmsg(const char *); +static void fail(const char *, const char *, int); +static void msg(const char *); +static void warn(const char *, const char *); + + + int main(int argc, char * argv[]) { std::cout << "using produce bk " <<PROCESS_CENTER_VERSION_MAJOR <<"."<< PROCESS_CENTER_VERSION_MINOR << endl; @@ -105,14 +115,179 @@ int main(int argc, char * argv[]) struct archive_entry *entry; int r; int flags = ARCHIVE_EXTRACT_TIME; // see https://linux.die.net/man/3/archive_write_disk for more flags - const char *filename = "recTest.tar"; + const char *filename = "data_sized.tar"; a = archive_read_new(); ext = archive_write_disk_new(); archive_write_disk_set_options(ext, flags); + /* + * Note: archive_write_disk_set_standard_lookup() is useful + * here, but it requires library routines that can add 500k or + * more to a static executable. + */ + archive_read_support_format_tar(a); + /* + * On my system, enabling other archive formats adds 20k-30k + * each. Enabling gzip decompression adds about 20k. + * Enabling bzip2 is more expensive because the libbz2 library + * isn't very well factored. + */ + if (filename != NULL && strcmp(filename, "-") == 0) + filename = NULL; + if ((r = archive_read_open_filename(a, filename, 10240))) + fail("archive_read_open_filename()", + archive_error_string(a), r); + int counter = 0; + for (;;) { + r = archive_read_next_header(a, &entry); + if (r == ARCHIVE_EOF) + break; + if (r != ARCHIVE_OK) + fail("archive_read_next_header()", + archive_error_string(a), 1); + + msg("x "); + ///char *buffer = malloc (sizeof(char) * 400000); + Mat img =Mat::zeros(1936,1456,CV_8UC3); + + //new way + //std::ifstream file("img.jpg"); + std::vector<char> vec; + + // file >> std::noskipws; + // std::copy(std::istream_iterator<char>(file), std::istream_iterator<char>(), std::back_inserter(data)); + + + + msg(archive_entry_pathname(entry)); + { + r = archive_write_header(ext, entry); + if (r != ARCHIVE_OK) + warn("archive_write_header()", + archive_error_string(ext)); + else + { + vec = copy_data(a, img.data);//no // we cast the data pointer to void, because we know what we do ?? + r = archive_write_finish_entry(ext); + if (r != ARCHIVE_OK) + fail("archive_write_finish_entry()", + archive_error_string(ext), 1); + } + + } + msg("\n"); + if(counter > 10) exit(1); + counter ++; - // capture.release(); - cvDestroyAllWindows(); + Mat img2 = imdecode(Mat(vec), 1); + + //we show what we got + namedWindow( "Display window", WINDOW_AUTOSIZE );// Create a window for display. + imshow( "Display window", img2 ); // Show our image inside it. + cv::imwrite("foo.jpg", img2); + + waitKey(0); + } + archive_read_close(a); + archive_read_free(a); + + archive_write_close(ext); + archive_write_free(ext); return 0; } + +static std::vector<char> copy_data(struct archive *aw, unsigned char *buffer) +{ + int r; + const void *buff; + std::vector<char> vec; + size_t size; +#if ARCHIVE_VERSION_NUMBER >= 3000000 + int64_t offset; +#else + off_t offset; +#endif + unsigned int myOffsetCounter = 0; + int counterIteration = 0; + + ofstream myfile; + myfile.open ("tmpPicture.jpg", ios::out | ios::binary); + if (!myfile.is_open()) + return vec; + + for (;;) { + r = archive_read_data_block(aw, &buff, &size, &offset); + if (r == ARCHIVE_EOF) + { + return vec; // everything fine + } + + if (r != ARCHIVE_OK) + { + cerr << "error during read archive "<<endl; + return vec; + } + //r = archive_write_data_block(aw, buff, size, offset); + //we mem copy the buffer + cout <<counterIteration++<< " offset: "<< offset<< " size: "<< size<<endl; + + //memcpy( &buffer[myOffsetCounter], (char*) buff, size * sizeof( char ) ); + //we simply copy it to the end + //std::copy ( buff, buff+size, vec.end() ); + myOffsetCounter += size; + + //a good discussion : https://stackoverflow.com/questions/259297/how-do-you-copy-the-contents-of-an-array-to-a-stdvector-in-c-without-looping + // // Method 2: Same as 1 but pre-extend the vector by the size of the array using reserve + // { + // vec.reserve(vec.size() + size); + // std::copy((char*) &buff[0],(char*) &buff[size], back_inserter(vec)); + // } + + // Method 4: vector::insert + { + //we rename our pointer + char *foo = (char*) buff; + vec.insert(vec.end(), &foo[0], &foo[size]); + } + + + myfile.write ((char*)buff,size); + // if (r != ARCHIVE_OK) { + // warn("archive_write_data_block()", + // archive_error_string(aw)); + // return (r); + // } + } + myfile.close(); + + return vec; +} + +static void +msg(const char *m) +{ + write(1, m, strlen(m)); +} + +static void +errmsg(const char *m) +{ + write(2, m, strlen(m)); +} + +static void +warn(const char *f, const char *m) +{ + errmsg(f); + errmsg(" failed: "); + errmsg(m); + errmsg("\n"); +} + +static void +fail(const char *f, const char *m, int r) +{ + warn(f, m); + exit(r); +}