It probably wasn't used or maintained for last few years.
E: radoslaw AT syskin DOT cjb DOT net
D: Cached motion compensation
-N: Tuukka Toivonen
-E: tuukkat AT ee DOT oulu DOT fi
-D: Visualization
-
SRCCLI += output/mp4_lsmash.c
endif
-# Visualization sources
-ifneq ($(findstring HAVE_VISUALIZE 1, $(CONFIG)),)
-SRCS += common/visualize.c common/display-x11.c
-endif
-
# MMX/SSE optims
ifneq ($(AS),)
X86SRC0 = const-a.asm cabac-a.asm dct-a.asm deblock-a.asm mc-a.asm \
}
OPT("log")
p->i_log_level = atoi(value);
-#if HAVE_VISUALIZE
- OPT("visualize")
- p->b_visualize = atobool(value);
-#endif
OPT("dump-yuv")
p->psz_dump_yuv = strdup(value);
OPT2("analyse", "partitions")
x264_deblock_function_t loopf;
x264_bitstream_function_t bsf;
-#if HAVE_VISUALIZE
- struct visualize_t *visualize;
-#endif
x264_lookahead_t *lookahead;
#if HAVE_OPENCL
+++ /dev/null
-/*****************************************************************************
- * display-x11.c: x11 interface
- *****************************************************************************
- * Copyright (C) 2005-2013 x264 project
- *
- * Authors: Tuukka Toivonen <tuukkat@ee.oulu.fi>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
- *
- * This program is also available under a commercial proprietary license.
- * For more information, contact us at licensing@x264.com.
- *****************************************************************************/
-
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "common.h"
-#include "display.h"
-
-static long event_mask = ConfigureNotify|ExposureMask|KeyPressMask|ButtonPressMask|StructureNotifyMask|ResizeRedirectMask;
-
-static Display *disp_display = NULL;
-static struct disp_window
-{
- int init;
- Window window;
-} disp_window[10];
-
-static inline void disp_chkerror( int cond, char *e )
-{
- if( !cond )
- return;
- fprintf( stderr, "error: %s\n", e ? e : "?" );
- abort();
-}
-
-static void disp_init_display( void )
-{
- Visual *visual;
- int dpy_class;
- int screen;
- int dpy_depth;
-
- if( disp_display )
- return;
- memset( &disp_window, 0, sizeof(disp_window) );
- disp_display = XOpenDisplay( "" );
- disp_chkerror( !disp_display, "no display" );
- screen = DefaultScreen( disp_display );
- visual = DefaultVisual( disp_display, screen );
- dpy_class = visual->class;
- dpy_depth = DefaultDepth( disp_display, screen );
- disp_chkerror( !((dpy_class == TrueColor && dpy_depth == 32)
- || (dpy_class == TrueColor && dpy_depth == 24)
- || (dpy_class == TrueColor && dpy_depth == 16)
- || (dpy_class == PseudoColor && dpy_depth == 8)),
- "requires 8 bit PseudoColor or 16/24/32 bit TrueColor display" );
-}
-
-static void disp_init_window( int num, int width, int height, const unsigned char *title )
-{
- XSetWindowAttributes xswa;
- XEvent xev;
- int screen = DefaultScreen(disp_display);
- Visual *visual = DefaultVisual (disp_display, screen);
- char buf[200];
- Window window;
-
- if( title )
- snprintf( buf, 200, "%s: %i/disp", title, num );
- else
- snprintf( buf, 200, "%i/disp", num );
-
- XSizeHints *shint = XAllocSizeHints();
- disp_chkerror( !shint, "memerror" );
- shint->min_width = shint->max_width = shint->width = width;
- shint->min_height = shint->max_height = shint->height = height;
- shint->flags = PSize | PMinSize | PMaxSize;
- disp_chkerror( num < 0 || num >= 10, "bad win num" );
- if( !disp_window[num].init )
- {
- unsigned int mask = 0;
- disp_window[num].init = 1;
- unsigned int bg = WhitePixel( disp_display, screen );
- unsigned int fg = BlackPixel( disp_display, screen );
- int dpy_depth = DefaultDepth( disp_display, screen );
- if( dpy_depth==32 || dpy_depth==24 || dpy_depth==16 )
- {
- mask |= CWColormap;
- xswa.colormap = XCreateColormap( disp_display, DefaultRootWindow( disp_display ), visual, AllocNone );
- }
- xswa.background_pixel = bg;
- xswa.border_pixel = fg;
- xswa.backing_store = Always;
- xswa.backing_planes = -1;
- xswa.bit_gravity = NorthWestGravity;
- mask = CWBackPixel | CWBorderPixel | CWBackingStore | CWBackingPlanes | CWBitGravity;
- window = XCreateWindow( disp_display, DefaultRootWindow( disp_display ),
- shint->x, shint->y, shint->width, shint->height,
- 1, dpy_depth, InputOutput, visual, mask, &xswa );
- disp_window[num].window = window;
-
- XSelectInput( disp_display, window, event_mask );
- XSetStandardProperties( disp_display, window, buf, buf, None, NULL, 0, shint );
- XMapWindow( disp_display, window );
-
- do {
- XNextEvent( disp_display, &xev );
- } while( xev.type != MapNotify || xev.xmap.event != window );
- }
- window = disp_window[num].window;
- XSetStandardProperties( disp_display, window, buf, buf, None, NULL, 0, shint );
- XResizeWindow( disp_display, window, width, height );
- XSync( disp_display, 1 );
- XFree( shint );
-}
-
-void disp_sync( void )
-{
- XSync( disp_display, 1 );
-}
-
-void disp_setcolor( unsigned char *name )
-{
- XColor c_exact, c_nearest;
-
- int screen = DefaultScreen( disp_display );
- GC gc = DefaultGC( disp_display, screen );
- Colormap cm = DefaultColormap( disp_display, screen );
- Status st = XAllocNamedColor( disp_display, cm, name, &c_nearest, &c_exact );
- disp_chkerror( st != 1, "XAllocNamedColor error" );
- XSetForeground( disp_display, gc, c_nearest.pixel );
-}
-
-void disp_gray( int num, char *data, int width, int height, int stride, const unsigned char *title )
-{
- char dummy;
-
- disp_init_display();
- disp_init_window( num, width, height, title );
- int screen = DefaultScreen( disp_display );
- Visual *visual = DefaultVisual( disp_display, screen );
- int dpy_depth = DefaultDepth( disp_display, screen );
- XImage *ximage = XCreateImage( disp_display, visual, dpy_depth, ZPixmap, 0, &dummy, width, height, 8, 0 );
- disp_chkerror( !ximage, "no ximage" );
-#if WORDS_BIGENDIAN
- ximage->byte_order = MSBFirst;
- ximage->bitmap_bit_order = MSBFirst;
-#else
- ximage->byte_order = LSBFirst;
- ximage->bitmap_bit_order = LSBFirst;
-#endif
-
- int pixelsize = dpy_depth>8 ? sizeof(int) : sizeof(unsigned char);
- uint8_t *image = malloc( width * height * pixelsize );
- disp_chkerror( !image, "malloc failed" );
- for( int y = 0; y < height; y++ )
- for( int x = 0; x < width; x++ )
- memset( &image[(width*y + x)*pixelsize], data[y*stride+x], pixelsize );
- ximage->data = image;
- GC gc = DefaultGC( disp_display, screen );
-
- XPutImage( disp_display, disp_window[num].window, gc, ximage, 0, 0, 0, 0, width, height );
- XPutImage( disp_display, disp_window[num].window, gc, ximage, 0, 0, 0, 0, width, height );
-
- XDestroyImage( ximage );
- XSync( disp_display, 1 );
-
-}
-
-void disp_gray_zoom(int num, char *data, int width, int height, int stride, const unsigned char *title, int zoom)
-{
- unsigned char *dataz = malloc( width*zoom * height*zoom );
- disp_chkerror( !dataz, "malloc" );
- for( int y = 0; y < height; y++ )
- for( int x = 0; x < width; x++ )
- for( int y0 = 0; y0 < zoom; y0++ )
- for( int x0 = 0; x0 < zoom; x0++ )
- dataz[(y*zoom + y0)*width*zoom + x*zoom + x0] = data[y*stride+x];
- disp_gray( num, dataz, width*zoom, height*zoom, width*zoom, title );
- free( dataz );
-}
-
-void disp_point( int num, int x1, int y1 )
-{
- int screen = DefaultScreen( disp_display );
- GC gc = DefaultGC( disp_display, screen );
- XDrawPoint( disp_display, disp_window[num].window, gc, x1, y1 );
-}
-
-void disp_line( int num, int x1, int y1, int x2, int y2 )
-{
- int screen = DefaultScreen( disp_display );
- GC gc = DefaultGC( disp_display, screen );
- XDrawLine( disp_display, disp_window[num].window, gc, x1, y1, x2, y2 );
-}
-
-void disp_rect( int num, int x1, int y1, int x2, int y2 )
-{
- int screen = DefaultScreen( disp_display );
- GC gc = DefaultGC( disp_display, screen );
- XDrawRectangle( disp_display, disp_window[num].window, gc, x1, y1, x2-x1, y2-y1 );
-}
+++ /dev/null
-/*****************************************************************************
- * display.h: x11 visualization interface
- *****************************************************************************
- * Copyright (C) 2005-2013 x264 project
- *
- * Authors: Tuukka Toivonen <tuukkat@ee.oulu.fi>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
- *
- * This program is also available under a commercial proprietary license.
- * For more information, contact us at licensing@x264.com.
- *****************************************************************************/
-
-#ifndef X264_DISPLAY_H
-#define X264_DISPLAY_H
-
-void disp_sync(void);
-void disp_setcolor(unsigned char *name);
-/* Display a region of byte wide memory as a grayscale image.
- * num is the window to use for displaying. */
-void disp_gray(int num, char *data, int width, int height,
- int stride, const unsigned char *title);
-void disp_gray_zoom(int num, char *data, int width, int height,
- int stride, const unsigned char *title, int zoom);
-void disp_point(int num, int x1, int y1);
-void disp_line(int num, int x1, int y1, int x2, int y2);
-void disp_rect(int num, int x1, int y1, int x2, int y2);
-
-#endif
+++ /dev/null
-/*****************************************************************************
- * visualize.c: visualization
- *****************************************************************************
- * Copyright (C) 2005-2013 x264 project
- *
- * Authors: Tuukka Toivonen <tuukkat@ee.oulu.fi>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
- *
- * This program is also available under a commercial proprietary license.
- * For more information, contact us at licensing@x264.com.
- *****************************************************************************/
-
-/*
- * Some explanation of the symbols used:
- * Red/pink: intra block
- * Blue: inter block
- * Green: skip block
- * Yellow: B-block (not visualized properly yet)
- *
- * Motion vectors have black dot at their target (ie. at the MB center),
- * instead of arrowhead. The black dot is enclosed in filled diamond with radius
- * depending on reference frame number (one frame back = zero width, normal case).
- *
- * The intra blocks have generally lines drawn perpendicular
- * to the prediction direction, so for example, if there is a pink block
- * with horizontal line at the top of it, it is interpolated by assuming
- * luma to be vertically constant.
- * DC predicted blocks have both horizontal and vertical lines,
- * pink blocks with a diagonal line are predicted using the planar function.
- */
-
-#include "common.h"
-#include "visualize.h"
-#include "display.h"
-
-typedef struct
-{
- int i_type;
- int i_partition;
- int i_sub_partition[4];
- int i_intra16x16_pred_mode;
- int intra4x4_pred_mode[4][4];
- int8_t ref[2][4][4]; /* [list][y][x] */
- int16_t mv[2][4][4][2]; /* [list][y][x][mvxy] */
-} visualize_t;
-
-/* Return string from stringlist corresponding to the given code */
-#define GET_STRING(sl, code) get_string((sl), sizeof(sl)/sizeof(*(sl)), code)
-
-typedef struct
-{
- int code;
- char *string;
-} stringlist_t;
-
-static char *get_string( const stringlist_t *sl, int entries, int code )
-{
- for( int i = 0; i < entries; i++ )
- if( sl[i].code == code )
- return sl[i].string;
- return "?";
-}
-
-/* Plot motion vector */
-static void mv( int x0, int y0, int16_t dmv[2], int ref, int zoom, char *col )
-{
- int dx = dmv[0];
- int dy = dmv[1];
-
- dx = (dx * zoom + 2) >> 2;
- dy = (dy * zoom + 2) >> 2;
- disp_line( 0, x0, y0, x0+dx, y0+dy );
- for( int i = 1; i < ref; i++ )
- {
- disp_line( 0, x0 , y0-i, x0+i, y0 );
- disp_line( 0, x0+i, y0 , x0 , y0+i );
- disp_line( 0, x0 , y0+i, x0-i, y0 );
- disp_line( 0, x0-i, y0 , x0 , y0-i );
- }
- disp_setcolor( "black" );
- disp_point( 0, x0, y0 );
- disp_setcolor( col );
-}
-
-int x264_visualize_init( x264_t *h )
-{
- CHECKED_MALLOC( h->visualize, h->mb.i_mb_width * h->mb.i_mb_height * sizeof(visualize_t) );
- return 0;
-fail:
- return -1;
-}
-
-void x264_visualize_mb( x264_t *h )
-{
- visualize_t *v = (visualize_t*)h->visualize + h->mb.i_mb_xy;
-
- /* Save all data for the MB that we need for drawing the visualization */
- v->i_type = h->mb.i_type;
- v->i_partition = h->mb.i_partition;
- for( int i = 0; i < 4; i++ )
- v->i_sub_partition[i] = h->mb.i_sub_partition[i];
- for( int y = 0; y < 4; y++ )
- for( int x = 0; x < 4; x++ )
- v->intra4x4_pred_mode[y][x] = h->mb.cache.intra4x4_pred_mode[X264_SCAN8_0+y*8+x];
- for( int l = 0; l < 2; l++ )
- for( int y = 0; y < 4; y++ )
- for( int x = 0; x < 4; x++ )
- {
- for( int i = 0; i < 2; i++ )
- v->mv[l][y][x][i] = h->mb.cache.mv[l][X264_SCAN8_0+y*8+x][i];
- v->ref[l][y][x] = h->mb.cache.ref[l][X264_SCAN8_0+y*8+x];
- }
- v->i_intra16x16_pred_mode = h->mb.i_intra16x16_pred_mode;
-}
-
-void x264_visualize_close( x264_t *h )
-{
- x264_free(h->visualize);
-}
-
-/* Display visualization (block types, MVs) of the encoded frame */
-/* FIXME: B-type MBs not handled yet properly */
-void x264_visualize_show( x264_t *h )
-{
- static const stringlist_t mb_types[] =
- {
- /* Block types marked as NULL will not be drawn */
- { I_4x4 , "red" },
- { I_8x8 , "#ff5640" },
- { I_16x16 , "#ff8060" },
- { I_PCM , "violet" },
- { P_L0 , "SlateBlue" },
- { P_8x8 , "blue" },
- { P_SKIP , "green" },
- { B_DIRECT, "yellow" },
- { B_L0_L0 , "yellow" },
- { B_L0_L1 , "yellow" },
- { B_L0_BI , "yellow" },
- { B_L1_L0 , "yellow" },
- { B_L1_L1 , "yellow" },
- { B_L1_BI , "yellow" },
- { B_BI_L0 , "yellow" },
- { B_BI_L1 , "yellow" },
- { B_BI_BI , "yellow" },
- { B_8x8 , "yellow" },
- { B_SKIP , "yellow" },
- };
-
- static const int waitkey = 1; /* Wait for enter after each frame */
- static const int drawbox = 1; /* Draw box around each block */
- static const int borders = 0; /* Display extrapolated borders outside frame */
- static const int zoom = 2; /* Zoom factor */
-
- static const int pad = 32;
- pixel *const frame = h->fdec->plane[0];
- const int width = h->param.i_width;
- const int height = h->param.i_height;
- const int stride = h->fdec->i_stride[0];
-
- if( borders )
- disp_gray_zoom( 0, frame - pad*stride - pad, width+2*pad, height+2*pad, stride, "fdec", zoom );
- else
- disp_gray_zoom( 0, frame, width, height, stride, "fdec", zoom );
-
- for( int mb_xy = 0; mb_xy < h->mb.i_mb_width * h->mb.i_mb_height; mb_xy++ )
- {
- visualize_t *const v = (visualize_t*)h->visualize + mb_xy;
- const int mb_y = mb_xy / h->mb.i_mb_width;
- const int mb_x = mb_xy % h->mb.i_mb_width;
- char *const col = GET_STRING( mb_types, v->i_type );
- int x = mb_x*16*zoom;
- int y = mb_y*16*zoom;
- int l = 0;
-
- if( !col )
- continue;
-
- if( borders )
- {
- x += pad*zoom;
- y += pad*zoom;
- }
-
- disp_setcolor( col );
- if( drawbox ) disp_rect( 0, x, y, x+16*zoom-1, y+16*zoom-1 );
-
- if( v->i_type==P_L0 || v->i_type==P_8x8 || v->i_type==P_SKIP )
- {
- /* Predicted (inter) mode, with motion vector */
- if( v->i_partition == D_16x16 || v->i_type == P_SKIP )
- mv( x+8*zoom, y+8*zoom, v->mv[l][0][0], v->ref[l][0][0], zoom, col );
- else if (v->i_partition == D_16x8)
- {
- if( drawbox ) disp_rect( 0, x, y, x+16*zoom, y+8*zoom );
- mv( x+8*zoom, y+4*zoom, v->mv[l][0][0], v->ref[l][0][0], zoom, col );
- if( drawbox ) disp_rect( 0, x, y+8*zoom, x+16*zoom, y+16*zoom );
- mv( x+8*zoom, y+12*zoom, v->mv[l][2][0], v->ref[l][2][0], zoom, col );
- }
- else if( v->i_partition==D_8x16 )
- {
- if( drawbox ) disp_rect( 0, x, y, x+8*zoom, y+16*zoom );
- mv( x+4*zoom, y+8*zoom, v->mv[l][0][0], v->ref[l][0][0], zoom, col );
- if( drawbox ) disp_rect( 0, x+8*zoom, y, x+16*zoom, y+16*zoom );
- mv( x+12*zoom, y+8*zoom, v->mv[l][0][2], v->ref[l][0][2], zoom, col );
- }
- else if( v->i_partition==D_8x8 )
- {
- for( int i = 0; i < 2; i++ )
- for( int j = 0; j < 2; j++ )
- {
- int sp = v->i_sub_partition[i*2+j];
- const int x0 = x + j*8*zoom;
- const int y0 = y + i*8*zoom;
- l = x264_mb_partition_listX_table[0][sp] ? 0 : 1; /* FIXME: not tested if this works */
- if( IS_SUB8x8(sp) )
- {
- if( drawbox ) disp_rect( 0, x0, y0, x0+8*zoom, y0+8*zoom );
- mv( x0+4*zoom, y0+4*zoom, v->mv[l][2*i][2*j], v->ref[l][2*i][2*j], zoom, col );
- }
- else if( IS_SUB8x4(sp) )
- {
- if( drawbox ) disp_rect( 0, x0, y0, x0+8*zoom, y0+4*zoom );
- if( drawbox ) disp_rect( 0, x0, y0+4*zoom, x0+8*zoom, y0+8*zoom );
- mv( x0+4*zoom, y0+2*zoom, v->mv[l][2*i][2*j], v->ref[l][2*i][2*j], zoom, col );
- mv( x0+4*zoom, y0+6*zoom, v->mv[l][2*i+1][2*j], v->ref[l][2*i+1][2*j], zoom, col );
- }
- else if( IS_SUB4x8(sp) )
- {
- if( drawbox ) disp_rect( 0, x0, y0, x0+4*zoom, y0+8*zoom );
- if( drawbox ) disp_rect( 0, x0+4*zoom, y0, x0+8*zoom, y0+8*zoom );
- mv( x0+2*zoom, y0+4*zoom, v->mv[l][2*i][2*j], v->ref[l][2*i][2*j], zoom, col );
- mv( x0+6*zoom, y0+4*zoom, v->mv[l][2*i][2*j+1], v->ref[l][2*i][2*j+1], zoom, col );
- }
- else if( IS_SUB4x4(sp) )
- {
- if( drawbox ) disp_rect( 0, x0, y0, x0+4*zoom, y0+4*zoom );
- if( drawbox ) disp_rect( 0, x0+4*zoom, y0, x0+8*zoom, y0+4*zoom );
- if( drawbox ) disp_rect( 0, x0, y0+4*zoom, x0+4*zoom, y0+8*zoom );
- if( drawbox ) disp_rect( 0, x0+4*zoom, y0+4*zoom, x0+8*zoom, y0+8*zoom );
- mv( x0+2*zoom, y0+2*zoom, v->mv[l][2*i][2*j], v->ref[l][2*i][2*j], zoom, col );
- mv( x0+6*zoom, y0+2*zoom, v->mv[l][2*i][2*j+1], v->ref[l][2*i][2*j+1], zoom, col );
- mv( x0+2*zoom, y0+6*zoom, v->mv[l][2*i+1][2*j], v->ref[l][2*i+1][2*j], zoom, col );
- mv( x0+6*zoom, y0+6*zoom, v->mv[l][2*i+1][2*j+1], v->ref[l][2*i+1][2*j+1], zoom, col );
- }
- }
- }
- }
-
- if( IS_INTRA(v->i_type) || v->i_type == I_PCM )
- {
- /* Intra coded */
- if( v->i_type == I_16x16 )
- {
- switch (v->i_intra16x16_pred_mode) {
- case I_PRED_16x16_V:
- disp_line( 0, x+2*zoom, y+2*zoom, x+14*zoom, y+2*zoom );
- break;
- case I_PRED_16x16_H:
- disp_line( 0, x+2*zoom, y+2*zoom, x+2*zoom, y+14*zoom );
- break;
- case I_PRED_16x16_DC:
- case I_PRED_16x16_DC_LEFT:
- case I_PRED_16x16_DC_TOP:
- case I_PRED_16x16_DC_128:
- disp_line( 0, x+2*zoom, y+2*zoom, x+14*zoom, y+2*zoom );
- disp_line( 0, x+2*zoom, y+2*zoom, x+2*zoom, y+14*zoom );
- break;
- case I_PRED_16x16_P:
- disp_line( 0, x+2*zoom, y+2*zoom, x+8*zoom, y+8*zoom );
- break;
- }
- }
- if( v->i_type==I_4x4 || v->i_type==I_8x8 )
- {
- const int di = v->i_type == I_8x8 ? 2 : 1;
- const int zoom2 = zoom * di;
- for( int i = 0; i < 4; i += di )
- for( int j = 0; j < 4; j += di )
- {
- const int x0 = x + j*4*zoom;
- const int y0 = y + i*4*zoom;
- if( drawbox ) disp_rect( 0, x0, y0, x0+4*zoom2, y0+4*zoom2 );
- switch( v->intra4x4_pred_mode[i][j] )
- {
- case I_PRED_4x4_V: /* Vertical */
- disp_line( 0, x0+0*zoom2, y0+1*zoom2, x0+4*zoom2, y0+1*zoom2 );
- break;
- case I_PRED_4x4_H: /* Horizontal */
- disp_line( 0, x0+1*zoom2, y0+0*zoom2, x0+1*zoom2, y0+4*zoom2 );
- break;
- case I_PRED_4x4_DC: /* DC, average from top and left sides */
- case I_PRED_4x4_DC_LEFT:
- case I_PRED_4x4_DC_TOP:
- case I_PRED_4x4_DC_128:
- disp_line( 0, x0+1*zoom2, y0+1*zoom2, x0+4*zoom2, y0+1*zoom2 );
- disp_line( 0, x0+1*zoom2, y0+1*zoom2, x0+1*zoom2, y0+4*zoom2 );
- break;
- case I_PRED_4x4_DDL: /* Topright-bottomleft */
- disp_line( 0, x0+0*zoom2, y0+0*zoom2, x0+4*zoom2, y0+4*zoom2 );
- break;
- case I_PRED_4x4_DDR: /* Topleft-bottomright */
- disp_line( 0, x0+0*zoom2, y0+4*zoom2, x0+4*zoom2, y0+0*zoom2 );
- break;
- case I_PRED_4x4_VR: /* Mix of topleft-bottomright and vertical */
- disp_line( 0, x0+0*zoom2, y0+2*zoom2, x0+4*zoom2, y0+1*zoom2 );
- break;
- case I_PRED_4x4_HD: /* Mix of topleft-bottomright and horizontal */
- disp_line( 0, x0+2*zoom2, y0+0*zoom2, x0+1*zoom2, y0+4*zoom2 );
- break;
- case I_PRED_4x4_VL: /* Mix of topright-bottomleft and vertical */
- disp_line( 0, x0+0*zoom2, y0+1*zoom2, x0+4*zoom2, y0+2*zoom2 );
- break;
- case I_PRED_4x4_HU: /* Mix of topright-bottomleft and horizontal */
- disp_line( 0, x0+1*zoom2, y0+0*zoom2, x0+2*zoom2, y0+4*zoom2 );
- break;
- }
- }
- }
- }
- }
-
- disp_sync();
- if( waitkey )
- getchar();
-}
-/* }}} */
-
-//EOF
+++ /dev/null
-/*****************************************************************************
- * visualize.h: visualization
- *****************************************************************************
- * Copyright (C) 2005-2013 x264 project
- *
- * Authors: Tuukka Toivonen <tuukkat@ee.oulu.fi>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
- *
- * This program is also available under a commercial proprietary license.
- * For more information, contact us at licensing@x264.com.
- *****************************************************************************/
-
-#ifndef X264_VISUALIZE_H
-#define X264_VISUALIZE_H
-
-#include "common/common.h"
-
-int x264_visualize_init( x264_t *h );
-void x264_visualize_mb( x264_t *h );
-void x264_visualize_show( x264_t *h );
-void x264_visualize_close( x264_t *h );
-
-#endif
--disable-thread disable multithreaded encoding
--enable-win32thread use win32threads (windows only)
--disable-interlaced disable interlaced encoding support
- --enable-visualize enable visualization (X11 only)
--bit-depth=BIT_DEPTH set output bit depth (8-10) [8]
--chroma-format=FORMAT output chroma format (420, 422, 444, all) [all]
gprof="no"
strip="no"
pic="no"
-vis="no"
bit_depth="8"
chroma_format="all"
compiler="GNU"
EXE=""
# list of all preprocessor HAVE values we can define
-CONFIG_HAVE="MALLOC_H ALTIVEC ALTIVEC_H MMX ARMV6 ARMV6T2 NEON BEOSTHREAD POSIXTHREAD WIN32THREAD THREAD LOG2F VISUALIZE SWSCALE \
+CONFIG_HAVE="MALLOC_H ALTIVEC ALTIVEC_H MMX ARMV6 ARMV6T2 NEON BEOSTHREAD POSIXTHREAD WIN32THREAD THREAD LOG2F SWSCALE \
LAVF FFMS GPAC AVS GPL VECTOREXT INTERLACED CPU_COUNT OPENCL THP LSMASH"
# parse options
--enable-pic)
pic="yes"
;;
- --enable-visualize)
- vis="yes"
- ;;
--host=*)
host="$optarg"
;;
define HAVE_THP
fi
-if [ "$vis" = "yes" ] ; then
- save_CFLAGS="$CFLAGS"
- CFLAGS="$CFLAGS -I/usr/X11R6/include"
- if cc_check "X11/Xlib.h" "-L/usr/X11R6/lib -lX11" "XOpenDisplay(0);" ; then
- LDFLAGS="-L/usr/X11R6/lib -lX11 $LDFLAGS"
- define HAVE_VISUALIZE
- else
- vis="no"
- CFLAGS="$save_CFLAGS"
- fi
-fi
-
if [ "$swscale" = "auto" ] ; then
swscale="no"
if ${cross_prefix}pkg-config --exists libswscale 2>/dev/null; then
gprof: $gprof
strip: $strip
PIC: $pic
-visualize: $vis
bit depth: $bit_depth
chroma format: $chroma_format
EOF
#include "macroblock.h"
#include "me.h"
-#if HAVE_VISUALIZE
-#include "common/visualize.h"
-#endif
-
//#define DEBUG_MB_TYPE
#define bs_write_ue bs_write_ue_big
BOOLIFY( b_sliced_threads );
BOOLIFY( b_interlaced );
BOOLIFY( b_intra_refresh );
- BOOLIFY( b_visualize );
BOOLIFY( b_aud );
BOOLIFY( b_repeat_headers );
BOOLIFY( b_annexb );
cont:
h->mb.b_reencode_mb = 0;
-#if HAVE_VISUALIZE
- if( h->param.b_visualize )
- x264_visualize_mb( h );
-#endif
-
/* save cache */
x264_macroblock_cache_save( h );
int i_slice_num = 0;
int last_thread_mb = h->sh.i_last_mb;
-#if HAVE_VISUALIZE
- if( h->param.b_visualize )
- if( x264_visualize_init( h ) )
- goto fail;
-#endif
-
/* init stats */
memset( &h->stat.frame, 0, sizeof(h->stat.frame) );
h->mb.b_reencode_mb = 0;
h->sh.i_first_mb -= h->mb.i_mb_stride;
}
-#if HAVE_VISUALIZE
- if( h->param.b_visualize )
- {
- x264_visualize_show( h );
- x264_visualize_close( h );
- }
-#endif
-
return (void *)0;
fail:
/* Ctrl-C handler */
static volatile int b_ctrl_c = 0;
-static int b_exit_on_ctrl_c = 0;
static void sigint_handler( int a )
{
- if( b_exit_on_ctrl_c )
- {
-#ifdef _WIN32
- SetConsoleTitleW( org_console_title );
-#endif
- exit( 0 );
- }
b_ctrl_c = 1;
}
H2( " --opencl Enable use of OpenCL\n" );
H2( " --opencl-clbin <string> Specify path of compiled OpenCL kernel cache\n" );
H2( " --opencl-device <integer> Specify OpenCL device ordinal\n" );
- H2( " --visualize Show MB types overlayed on the encoded video\n" );
H2( " --dump-yuv <string> Save reconstructed frames\n" );
H2( " --sps-id <integer> Set SPS and PPS id numbers [%d]\n", defaults->i_sps_id );
H2( " --aud Use access unit delimiters\n" );
OPT_THREAD_INPUT,
OPT_QUIET,
OPT_NOPROGRESS,
- OPT_VISUALIZE,
OPT_LONGHELP,
OPT_PROFILE,
OPT_PRESET,
{ "verbose", no_argument, NULL, 'v' },
{ "log-level", required_argument, NULL, OPT_LOG_LEVEL },
{ "no-progress", no_argument, NULL, OPT_NOPROGRESS },
- { "visualize", no_argument, NULL, OPT_VISUALIZE },
{ "dump-yuv", required_argument, NULL, 0 },
{ "sps-id", required_argument, NULL, 0 },
{ "aud", no_argument, NULL, 0 },
case OPT_NOPROGRESS:
opt->b_progress = 0;
break;
- case OPT_VISUALIZE:
-#if HAVE_VISUALIZE
- param->b_visualize = 1;
- b_exit_on_ctrl_c = 1;
-#else
- x264_cli_log( "x264", X264_LOG_WARNING, "not compiled with visualization support\n" );
-#endif
- break;
case OPT_TUNE:
case OPT_PRESET:
break;
#include "x264_config.h"
-#define X264_BUILD 139
+#define X264_BUILD 140
/* Application developers planning to link against a shared library version of
* libx264 from a Microsoft Visual Studio or similar development environment
void (*pf_log)( void *, int i_level, const char *psz, va_list );
void *p_log_private;
int i_log_level;
- int b_visualize;
int b_full_recon; /* fully reconstruct frames, even when not necessary for encoding. Implied by psz_dump_yuv */
char *psz_dump_yuv; /* filename (in UTF-8) for reconstructed frames */
projects / x264 / commitdiff