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;
}
struct vram_info * get_yuv422_hd_vram()
{
vram_params_update_if_dirty();
//~ #ifndef CONFIG_5DC
if (!lv) // play/quickreview, HD buffer not active => use LV instead
return get_yuv422_vram();
//~ #endif
vram_hd.vram = CACHEABLE(YUV422_HD_BUFFER_DMA_ADDR);
return &vram_hd;
}
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;
}
void vram_clear_lv()
{
struct vram_info * lv_vram = get_yuv422_vram();
memset(lv_vram->vram, 0, lv_vram->height * lv_vram->pitch);
}
void green_screen_step()
{
/****************************************************
* .. if Canon menu is ACTIVE - return immediately *
****************************************************/
if (!lv)
{
last_green_screen_state = 0;
return;
}
/********************************
* Masses of auto variables. *
********************************/
// unsigned int Xs,Xe; // X_POSITION of Cropmark_start/_end
//~ Xs = g_cropmark_x_start; // First Pix drawn on (and a multiple of 4)
//~ Xe = g_cropmark_x_end; // First Pix not drawn on (multiple of 4)
// unsigned int Vram_pixels = Xe - Xs;
unsigned int vpix, lum1, lum2;
// results from previous loop, used for display
static int total_luma = 0;
static int highest_luma = 0;
static int lowest_luma = 256;
static int total_pixels = 0;
// results for current loop, being updated (will be used at next loop)
unsigned int total_luma_tmp = 0;
unsigned int highest_luma_tmp = 0;
unsigned int lowest_luma_tmp = 256;
unsigned int total_pixels_tmp = 0;
/****************************************************************
* Set address pointers up to first line in Vram *
****************************************************************/
uint32_t* lv = (uint32_t *) get_yuv422_vram()->vram;
if (!lv) return;
uint8_t* bm = bmp_vram();
// uint16_t* bm16 = (uint16_t *) bmp_vram();
uint8_t* bm_mirror = (uint8_t *) get_bvram_mirror();
unsigned int average_luma = total_luma / total_pixels;
unsigned int high_delta = highest_luma - average_luma; // used to work out colour scale
unsigned int low_delta = average_luma - lowest_luma; // colour scale for darker pixels
/******************************************************************
* Go through Crop area. Note highest and lowest luma, average *
******************************************************************/
int high_delta_factor = 1024 / high_delta; // replace division with multiplication
int low_delta_factor = 1024 / low_delta;
for(int y = os.y0 + os.off_169; y < os.y_max - os.off_169; y += 2 )
{
uint32_t * const v_row = (uint32_t*)( lv + BM2LV_R(y) ); // 2 pixels
uint16_t * const b_row = (uint16_t*)( bm + BM_R(y) ); // 2 pixels
uint16_t * const m_row = (uint16_t*)( bm_mirror + BM_R(y) ); // 2 pixels
uint8_t* lvp; // that's a moving pointer through lv vram
uint16_t* bp; // through bmp vram
uint16_t* mp; // through mirror
for (int x = os.x0; x < os.x_max; x += 2)
{
lvp = (uint8_t *) (v_row + BM2LV_X(x)/2); lvp++;
bp = b_row + x/2;
mp = m_row + x/2;
/********************************************
* Get 4 bytes of vram (ie two vram Pixels) *
********************************************/
// vpix = [LSB=pix on left] u y1 v y2 [MSB=pix on right]
vpix = lv[BM2LV(x,y)/4];
total_pixels_tmp += 2;
lum1 = ( vpix & 0x0000FF00 ) >> 8; // y1
lum2 = ( vpix & 0xFF000000 ) >> 24; // y2
/*************************
* Update total luma *
*************************/
total_luma_tmp += lum1 + lum2;
/*************************
* new Maximum ? *
*************************/
if (lum1 > highest_luma_tmp)
highest_luma_tmp = lum1;
if (lum2 > highest_luma_tmp)
highest_luma_tmp = lum2;
/*************************
* new Miniumum ? *
*************************/
if (lum1 < lowest_luma_tmp)
lowest_luma_tmp = lum1;
if (lum2 < lowest_luma_tmp)
lowest_luma_tmp = lum2;
/*********************************************************
* Initialise writeback colour of overlay to 0 for LUM1 *
*********************************************************/
unsigned int lum = (lum1 + lum2) / 2;
unsigned int col = 0;
/**************************************
* LUM1 Higher than average luma *
**************************************/
if (lum > average_luma)
{
col = ((lum-average_luma)*12) * high_delta_factor / 1024;
if (col > 12)
col=12;
col = 128 + (col+2) * 8;
}
else if (lum < average_luma)
{
/**************************************
* LUM1 Lower than average luma *
**************************************/
col = ((average_luma-lum)*12) * low_delta_factor / 1024;
if (col > 12)
col=12;
col = 128 - (col+2) * 8;
}
if (col) col = ((col * 41) >> 8) + 38;
unsigned int c = col | (col << 8);
#define BP (*bp)
#define MP (*mp)
#define BN (*(bp + BMPPITCH/2))
#define MN (*(mp + BMPPITCH/2))
if (BP != 0 && BP != MP) { continue; }
if (BN != 0 && BN != MN) { continue; }
if ((MP & 0x80808080) || (MN & 0x80808080)) continue;
MP = BP = c;
MN = BN = c;
#undef BP
#undef MP
#undef BN
#undef MN
}
} // end of (y loop)
/**********************************
* commit statistics for next loop *
**********************************/
total_luma = total_luma_tmp;
highest_luma = highest_luma_tmp;
lowest_luma = lowest_luma_tmp;
total_pixels = total_pixels_tmp;
/**********************************
* Display average, min and max *
**********************************/
bmp_printf( FONT(FONT_MED, COLOR_WHITE, COLOR_BLACK),
os.x0 + os.x_ex/2 - font_med.width*7, os.y_max - os.off_169 - 47,
"Average = %03d",average_luma);
bmp_printf( FONT(FONT_MED,COLOR_CYAN, COLOR_BLACK),
os.x0, os.y_max - os.off_169 - 47,
"MIN = %03d",lowest_luma);
bmp_printf( FONT(FONT_MED,COLOR_YELLOW, COLOR_BLACK),
os.x_max - font_med.width*9,
os.y_max - os.off_169 - 47,
"%03d = MAX",highest_luma);
bmp_printf( FONT(FONT_MED,COLOR_WHITE, COLOR_BLACK),
os.x0 + os.x_ex/2 - font_med.width*7, os.y_max - os.off_169 - 27,
"Accuracy=%03d%%",((255-(highest_luma-lowest_luma))*99 )/255
);
bmp_printf( FONT(FONT_MED,COLOR_CYAN, COLOR_BLACK),
os.x0, os.y_max - os.off_169 - 27,
"delta %03d", COERCE(average_luma - lowest_luma, 0, 255));
bmp_printf( FONT(FONT_MED, COLOR_YELLOW, COLOR_BLACK),
os.x_max - font_med.width*9,
os.y_max - os.off_169 - 27,
"%03d delta", COERCE(highest_luma - average_luma, 0, 255));
msleep(10); // don't kill the battery :)
} /* end of green_screen_step() */
void draw_false_downsampled( void )
{
//~ if (vram_width > 720) return;
//~ if (!PLAY_MODE)
//~ {
//~ if (!expsim) return;
//~ }
// exception: green screen palette is not fixed
if (falsecolor_palette == 5)
{
green_screen_step();
return;
}
//~ bvram_mirror_init();
uint8_t * const bvram = bmp_vram_real();
if (!bvram) return;
uint8_t * const bvram_mirror = get_bvram_mirror();
if (!bvram_mirror) return;
uint8_t * const lvram = get_yuv422_vram()->vram;
uint8_t* fc = false_colour[falsecolor_palette];
int off = get_y_skip_offset_for_overlays();
for(int y = os.y0 + off; y < os.y_max - off; y += 2 )
{
uint32_t * const v_row = (uint32_t*)( lvram + BM2LV_R(y) ); // 2 pixels
uint16_t * const b_row = (uint16_t*)( bvram + BM_R(y) ); // 2 pixels
uint16_t * const m_row = (uint16_t*)( bvram_mirror + BM_R(y) ); // 2 pixels
uint8_t* lvp; // that's a moving pointer through lv vram
uint16_t* bp; // through bmp vram
uint16_t* mp; // through mirror
for (int x = os.x0; x < os.x_max; x += 2)
{
lvp = (uint8_t *)(v_row + BM2LV_X(x)/2); lvp++;
bp = b_row + x/2;
mp = m_row + x/2;
#define BP (*bp)
#define MP (*mp)
#define BN (*(bp + BMPPITCH/2))
#define MN (*(mp + BMPPITCH/2))
if (BP != 0 && BP != MP) { little_cleanup(bp, mp); continue; }
if (BN != 0 && BN != MN) { little_cleanup(bp + BMPPITCH/2, mp + BMPPITCH/2); continue; }
if ((MP & 0x80808080) || (MN & 0x80808080)) continue;
int c = fc[*lvp]; c |= (c << 8);
MP = BP = c;
MN = BN = c;
#undef BP
#undef MP
#undef BN
#undef MN
}
}
}