static int yuv422_show(char* filename)
{
uint32_t size;
if( FIO_GetFileSize( filename, &size ) != 0 ) return 0;
uint32_t * buf = fio_malloc(size);
if (!buf) return 0;
struct vram_info * vram = get_yuv422_vram();
if (!vram->vram) goto err;
clrscr();
bmp_printf(FONT_MED, 600, 460, "%d", size);
int w,h;
// auto-generated code from 422-jpg.py
if (size == 1120 * 746 * 2) { w = 1120; h = 746; }
else if (size == 1872 * 1080 * 2) { w = 1872; h = 1080; }
else if (size == 1024 * 680 * 2) { w = 1024; h = 680; }
else if (size == 1560 * 884 * 2) { w = 1560; h = 884; }
else if (size == 944 * 632 * 2) { w = 944; h = 632; }
else if (size == 928 * 616 * 2) { w = 928; h = 616; }
else if (size == 1576 * 1048 * 2) { w = 1576; h = 1048; }
else if (size == 1576 * 632 * 2) { w = 1576; h = 632; }
else if (size == 720 * 480 * 2) { w = 720; h = 480; }
else if (size == 1056 * 704 * 2) { w = 1056; h = 704; }
else if (size == 1720 * 974 * 2) { w = 1720; h = 974; }
else if (size == 1280 * 580 * 2) { w = 1280; h = 580; }
else if (size == 640 * 480 * 2) { w = 640; h = 480; }
else if (size == 1024 * 680 * 2) { w = 1024; h = 680; }
else if (size == 1056 * 756 * 2) { w = 1056; h = 756; }
else if (size == 1728 * 972 * 2) { w = 1728; h = 972; }
else if (size == 1680 * 945 * 2) { w = 1680; h = 945; }
else if (size == 1280 * 560 * 2) { w = 1280; h = 560; }
else if (size == 1152 * 768 * 2) { w = 1152; h = 768; }
else if (size == 1904 * 1274 * 2) { w = 1904; h = 1274; }
else if (size == 1620 * 1080 * 2) { w = 1620; h = 1080; }
else if (size == 1280 * 720 * 2) { w = 1280; h = 720; }
else if (size == 1808 * 1206 * 2) { w = 1808; h = 1206; } // 6D Movie
else if (size == 1816 * 1210 * 2) { w = 1816; h = 1210; } // 6D Photo
else if (size == 1104 * 736 * 2) { w = 1104; h = 736; } // 6D Zoom
else if (size == 1680 * 952 * 2) { w = 1680; h = 952; } // 600D
else if (size == 1728 * 972 * 2) { w = 1728; h = 972; } // 600D Crop
else if (size == 960 * 639 * 2) { w = 960; h = 639; } // 650D LV STDBY
else if (size == 1729 * 1151 * 2) { w = 1728; h = 1151; } // 650D 1080p/480p recording
else if (size == 1280 * 689 * 2) { w = 1280; h = 689; } // 650D 720p recording
else goto err;
bmp_printf(FONT_MED, 600, 460, " %dx%d ", w, h);
size_t rc = read_file( filename, buf, size );
if( rc != size ) goto err;
yuv_resize(buf, w, h, (uint32_t*)vram->vram, vram->width, vram->height);
fio_free(buf);
return 1;
err:
fio_free(buf);
return 0;
}
static int ppm_show(char* filename)
{
uint32_t size;
if( FIO_GetFileSize( filename, &size ) != 0 ) return 0;
char * buf = fio_malloc(size);
size_t rc = read_file( filename, buf, size );
if( rc != size ) goto err;
struct vram_info * vram = get_yuv422_vram();
uint32_t * lvram = (uint32_t *)vram->vram;
if (!lvram) goto err;
/* only ML screenshots are supported for now, to keep things simple */
char* ml_header = "P6\n720 480\n255\n";
if (strncmp(buf, ml_header, strlen(ml_header)))
goto err;
char* rgb = buf + strlen(ml_header);
for (int y = 0; y < 480; y++)
{
for (int x = 0; x < 720; x++)
{
int R = rgb[(y*720 + x)*3 ];
int G = rgb[(y*720 + x)*3 + 1];
int B = rgb[(y*720 + x)*3 + 2];
uint32_t uyvy = rgb2yuv422(R, G, B);
int pixoff_dst = LV(x,y) / 2;
uint32_t* dst = &lvram[pixoff_dst / 2];
uint32_t mask = (pixoff_dst % 2 ? 0xffFF00FF : 0x00FFffFF);
*(dst) = (uyvy & mask) | (*(dst) & ~mask);
}
}
fio_free(buf);
return 1;
err:
fio_free(buf);
return 0;
}
static int script_load_symbols(void* tcc, void* script_state, char *filename)
{
uint32_t size = 0;
FILE* file = NULL;
char *buf = NULL;
uint32_t count = 0;
uint32_t pos = 0;
if( FIO_GetFileSize( filename, &size ) != 0 )
{
console_printf("Error loading '%s': File does not exist\n", filename);
return -1;
}
buf = fio_malloc(size);
if(!buf)
{
console_printf("Error loading '%s': File too large\n", filename);
return -1;
}
file = FIO_OpenFile(filename, O_RDONLY | O_SYNC);
if(!file)
{
console_printf("Error loading '%s': File does not exist\n", filename);
fio_free(buf);
return -1;
}
FIO_ReadFile(file, buf, size);
FIO_CloseFile(file);
while(buf[pos])
{
char address_buf[16];
char symbol_buf[128];
uint32_t length = 0;
uint32_t address = 0;
while(buf[pos + length] && buf[pos + length] != ' ' && length < sizeof(address_buf))
{
address_buf[length] = buf[pos + length];
length++;
}
address_buf[length] = '\000';
pos += length + 1;
length = 0;
while(buf[pos + length] && buf[pos + length] != '\r' && buf[pos + length] != '\n' && length < sizeof(symbol_buf))
{
symbol_buf[length] = buf[pos + length];
length++;
}
symbol_buf[length] = '\000';
pos += length + 1;
length = 0;
while(buf[pos + length] && (buf[pos + length] == '\r' || buf[pos + length] == '\n'))
{
pos++;
}
sscanf(address_buf, "%x", &address);
module_exec(tcc, "tcc_add_symbol", 3, script_state, symbol_buf, (void*)address);
count++;
}
/* ToDo: parse the old plugin sections as all needed OS stubs are already described there */
module_exec(tcc, "tcc_add_symbol", 3, script_state, "strcpy", &strcpy);
module_exec(tcc, "tcc_add_symbol", 3, script_state, "strlen", &strlen);
fio_free(buf);
return 0;
}
void lv_rec_start()
{
int yPos = 3;
lv_rec_data_t data;
lv_rec_save_data_t save_data;
/* set all values to zero */
memset(&data, 0x00, sizeof(lv_rec_data_t));
memset(&save_data, 0x00, sizeof(lv_rec_save_data_t));
/* menu options */
data.options.frameSkip = lv_rec_frame_skip;
data.options.rawMode = lv_rec_raw_mode;
data.options.singleFile = lv_rec_single_file;
data.options.linesToSkip = lv_rec_line_skip;
/* this causes the function to hang!? */
if(data.options.rawMode)
{
//~ bmp_printf( FONT(FONT_MED, COLOR_WHITE, COLOR_BLACK), 30, 20 * yPos++, "Make sure you ran call('lv_save_raw')");
call("lv_save_raw", 1);
msleep(200);
raw_update_params();
}
/* get maximum available memory */
bmp_printf( FONT(FONT_MED, COLOR_WHITE, COLOR_BLACK), 30, 20 * yPos++, "Allocating memory");
data.chunkData.memSuite = shoot_malloc_suite(0);
if(!data.chunkData.memSuite)
{
bmp_printf( FONT(FONT_MED, COLOR_WHITE, COLOR_BLACK), 30, 20 * yPos++, "Failed to allocate memory");
return;
}
unsigned int allocatedMemory = lv_rec_get_memsize(data.chunkData.memSuite);
bmp_printf( FONT(FONT_MED, COLOR_WHITE, COLOR_BLACK), 30, 20 * yPos++, "Allocated %d MiB", allocatedMemory/1024/1024);
save_data.options = data.options;
save_data.chunkData = data.chunkData;
/* ensure the selected profile is applied, dont rely on menu painting to do this for us */
lv_rec_update_preset(&save_data);
/* file sequence number */
int start_number = 0;
/* set file pre/suffixes */
if(data.options.singleFile)
{
strcpy(save_data.filePrefix, "M");
}
else
{
strcpy(save_data.filePrefix, "I");
}
if(data.options.rawMode)
{
strcpy(save_data.fileSuffix, "RAW");
}
else
{
strcpy(save_data.fileSuffix, "YUV");
}
/* get first available file name */
for (start_number = 0 ; start_number < 1000; start_number++)
{
snprintf(save_data.fileName, sizeof(save_data.fileName), "%s%s%07d.%s", MODULE_CARD_DRIVE, save_data.filePrefix, start_number, save_data.fileSuffix);
uint32_t size;
if( FIO_GetFileSize( save_data.fileName, &size ) != 0 ) break;
if (size == 0) break;
}
if(data.options.rawMode)
{
/* copy 8 bytes per transfer */
data.dmaFlags = 0x20001000;
/* set block size for EDMAC and update cropping */
save_data.frameSize = (save_data.frameSizeReal + 4095) & (~4095);
/* the data at bottom are trash remains caused by EDMAC block size, drop it */
save_data.bottomDrop = save_data.frameSize - save_data.frameSizeReal;
/* mem copy connection */
data.dmaCopyChannel = 0x19;
data.dmaCopyConn = 0x06;
data.dmaSourceConn = 0x06;
data.dmaFlags = 0;
/* create a memory suite that consists of lv_save_raw raw buffer */
data.memCopySuite = CreateMemorySuite((void*)shamem_read(RAW_LV_EDMAC), save_data.frameSize, 0);
PackMem_RegisterEDmacCompleteCBRForMemorySuite(data.dmaCopyChannel, &complete_cbr, 0);
PackMem_RegisterEDmacPopCBRForMemorySuite(data.dmaCopyChannel, &pop_cbr, 0);
}
else
{
/* copy 2 byte per transfer */
data.dmaFlags = 0x20000000;
/* read from YUV connection */
data.dmaSourceConn = 0x1B;
/* no special treatment, save the exact size */
save_data.frameSize = save_data.frameSizeReal;
save_data.bottomDrop = 0;
}
/* who wants to save more? */
data.maxFrames = 200000;
data.dmaChannel = 0x11;
data.maxFramesBufferable = allocatedMemory / save_data.frameSize;
data.frameSize = save_data.frameSize;
/* EDMAC callbacks */
PackMem_RegisterEDmacCompleteCBRForMemorySuite(data.dmaChannel, &complete_cbr, 1);
PackMem_RegisterEDmacPopCBRForMemorySuite(data.dmaChannel, &pop_cbr, 1);
/* this enables recording */
lv_rec_state = &data;
bmp_printf( FONT(FONT_MED, COLOR_WHITE, COLOR_BLACK), 30, 20 * yPos++, "Ready, waiting for first frame");
int wait_loops = 0;
int t0 = get_ms_clock_value();
while(!data.finished || (lv_rec_ring_mode && (data.capturedFrames > data.savedFrames)))
{
if(lv_rec_ring_mode)
{
if(data.capturedFrames > data.savedFrames)
{
if(data.options.singleFile)
{
if(!save_data.handle)
{
snprintf(save_data.fileName, sizeof(save_data.fileName), "%s%s%07d.%s", MODULE_CARD_DRIVE, save_data.filePrefix, start_number, save_data.fileSuffix);
bmp_printf( FONT(FONT_MED, COLOR_WHITE, COLOR_BLACK), 30, 20 * (yPos+1), "Saving to '%s'", save_data.fileName);
save_data.handle = FIO_CreateFileEx(save_data.fileName);
save_data.handleWritten = 0;
}
if(save_data.handle)
{
/* save or skip, depending on skip counter */
save_data.handleWritten += lv_rec_save_frame(save_data.handle, &save_data, (data.savedFrames % data.options.frameSkip) != 0);
}
else
{
yPos++;
bmp_printf( FONT(FONT_MED, COLOR_WHITE, COLOR_BLACK), 30, 20 * yPos++, "Failed to save file");
break;
}
/* when reaching 2GiB, create another file */
if(save_data.handleWritten > ((2UL * 1024UL) - 10UL) * 1024UL * 1024UL)
{
yPos++;
bmp_printf( FONT(FONT_MED, COLOR_WHITE, COLOR_BLACK), 30, 20 * yPos++, "Creating next file");
FIO_CloseFile(save_data.handle);
save_data.handle = NULL;
lv_rec_update_suffix(&save_data);
save_data.fileSeqNum++;
}
data.savedFrames++;
}
else
{
if((data.savedFrames % data.options.frameSkip) == 0)
{
snprintf(save_data.fileName, sizeof(save_data.fileName), "%s%s%07d.%s", MODULE_CARD_DRIVE, save_data.filePrefix, start_number + (data.savedFrames / data.options.frameSkip), save_data.fileSuffix);
bmp_printf( FONT(FONT_MED, COLOR_WHITE, COLOR_BLACK), 30, 20 * (yPos+1), "Saving '%s'", save_data.fileName);
save_data.handle = FIO_CreateFileEx(save_data.fileName);
save_data.handleWritten = 0;
if(save_data.handle)
{
save_data.handleWritten += lv_rec_save_frame(save_data.handle, &save_data, 0);
save_data.frameCount = 1;
lv_rec_save_footer(save_data.handle, &save_data);
FIO_CloseFile(save_data.handle);
save_data.handle = NULL;
}
else
{
yPos++;
bmp_printf( FONT(FONT_MED, COLOR_WHITE, COLOR_BLACK), 30, 20 * yPos++, "Failed to save file");
break;
}
}
else
{
/* do not save data, just skip buffers */
lv_rec_save_frame(save_data.handle, &save_data, 1);
}
data.savedFrames++;
}
/* reset timeout counter */
wait_loops = 0;
}
else
{
msleep(10);
if(wait_loops++ > 25)
{
yPos++;
bmp_printf( FONT(FONT_MED, COLOR_WHITE, COLOR_BLACK), 30, 20 * yPos++, "No more data, aborting.");
lv_rec_state = NULL;
PackMem_PopEDmacForMemorySuite(data.dmaChannel);
data.finished = 1;
}
}
}
else
{
msleep(200);
}
int t1 = get_ms_clock_value();
int speed = (save_data.handleWritten / 1024) * 10 / (t1 - t0) * 1000 / 1024; // MB/s x10
bmp_printf( FONT(FONT_MED, COLOR_WHITE, COLOR_BLACK), 30, 20 * yPos,
"%s, %d buffered, %d saved, %d.%d MB/s ",
(data.finished?"Finished":(data.running?"Recording":"Wait.....")),
data.capturedFrames - data.savedFrames,
data.savedFrames / data.options.frameSkip,
speed/10, speed%10
);
}
yPos++;
if(lv_rec_ring_mode)
{
if(data.options.singleFile)
{
save_data.frameCount = data.capturedFrames;
lv_rec_save_footer(save_data.handle, &save_data);
FIO_CloseFile(save_data.handle);
}
}
else
{
bmp_printf( FONT(FONT_MED, COLOR_WHITE, COLOR_BLACK), 30, 20 * ++yPos, "Saving");
if(data.options.singleFile)
{
/* save one single file */
bmp_printf( FONT(FONT_MED, COLOR_WHITE, COLOR_BLACK), 30, 20 * ++yPos, "Saved: 0x%08X", exmem_save_buffer(data.chunkData.memSuite, "DATA.BIN"));
}
}
bmp_printf( FONT(FONT_MED, COLOR_WHITE, COLOR_BLACK), 30, 20 * ++yPos, "Recording finished");
shoot_free_suite(data.chunkData.memSuite);
/* the dummy suite that points to lv_save_raw buffer */
if(data.memCopySuite)
{
DeleteMemorySuite(data.memCopySuite);
}
}
static int dng_show(char* filename)
{
uint32_t size;
if( FIO_GetFileSize( filename, &size ) != 0 ) return 0;
FILE* f = FIO_OpenFile(filename, O_RDONLY | O_SYNC);
void* buf = 0;
/* should be big enough for the header */
int header_maxsize = 65536;
int* header = fio_malloc(header_maxsize);
if (!header) return 0;
int rc = FIO_ReadFile(f, header, header_maxsize);
if( rc != header_maxsize ) goto err;
if (header[0] != 0x002A4949 && header[1] != 0x00000008)
{
bmp_printf(FONT_MED, 0, 0, "Not a CHDK DNG");
goto err;
}
raw_info.width = 0;
raw_info.height = 0;
int strip_offset = 0;
int off = 8;
for (int ifd = 0; off; ifd++)
off = tif_parse_ifd(ifd, (void*)header, off, &strip_offset);
fio_free(header); header = 0;
if (!strip_offset) goto err;
if (!raw_info.width) goto err;
if (!raw_info.height) goto err;
int raw_size = raw_info.width * raw_info.height * 14/8;
buf = fio_malloc(raw_size);
if (!buf) goto err;
FIO_SeekSkipFile(f, strip_offset, SEEK_SET);
rc = FIO_ReadFile(f, buf, raw_size);
if (rc != raw_size) goto err;
FIO_CloseFile(f); f = 0;
info_led_on();
/* fixme: this step is really slow */
reverse_bytes_order(buf, raw_size);
info_led_off();
raw_info.buffer = buf;
raw_set_geometry(raw_info.width, raw_info.height, raw_info.active_area.x1, raw_info.width - raw_info.active_area.x2, raw_info.active_area.y1, raw_info.height - raw_info.active_area.y2);
raw_force_aspect_ratio_1to1();
vram_clear_lv();
raw_preview_fast_ex((void*)-1, (void*)-1, -1, -1, RAW_PREVIEW_COLOR_HALFRES);
fio_free(buf); buf = 0;
raw_set_dirty();
bmp_printf(FONT_MED, 600, 460, " %dx%d ", raw_info.jpeg.width, raw_info.jpeg.height);
return 1;
err:
if (f) FIO_CloseFile(f);
if (header) fio_free(header);
if (buf) fio_free(buf);
raw_set_dirty();
return 0;
}
int config_flag_file_setting_load(char* file)
{
uint32_t size;
return ( FIO_GetFileSize( file, &size ) == 0 );
}
