Projectname large_stringclasses 15
values | Filepath large_stringlengths 4 106 ⌀ | Function large_stringlengths 11 3.45k | Label list |
|---|---|---|---|
Chromium | third_party/libpng/pngerror.c | size_t png_safecat(png_charp buffer, size_t bufsize, size_t pos,
png_const_charp string) {
if (buffer != NULL && pos < bufsize) {
if (string != NULL)
while (*string != '\0' && pos < bufsize - 1)
buffer[pos++] = *string++;
buffer[pos] = '\0';
}
return pos;
} | [
1,
0
] |
Chromium | third_party/libpng/pngerror.c | void PNGAPI png_warning(png_const_structrp png_ptr,
png_const_charp warning_message) {
int offset = 0;
if (png_ptr != NULL) {
#ifdef PNG_ERROR_NUMBERS_SUPPORTED
if ((png_ptr->flags &
(PNG_FLAG_STRIP_ERROR_NUMBERS | PNG_FLAG_STRIP_ERROR_TEXT)) != 0)
#endif
{
if (*warnin... | [
1,
0
] |
Chromium | third_party/libpng/pngerror.c | void png_app_error(png_const_structrp png_ptr, png_const_charp error_message) {
if ((png_ptr->flags & PNG_FLAG_APP_ERRORS_WARN) != 0)
png_warning(png_ptr, error_message);
else
png_error(png_ptr, error_message);
#ifndef PNG_ERROR_TEXT_SUPPORTED
PNG_UNUSED(error_message)
#endif
}
#endif
#define PNG_MAX_ER... | [
1,
0
] |
Chromium | third_party/libpng/pngerror.c | void png_chunk_report(png_const_structrp png_ptr, png_const_charp message,
int error) {
#ifndef PNG_WARNINGS_SUPPORTED
PNG_UNUSED(message)
#endif
#if defined(PNG_READ_SUPPORTED) && defined(PNG_WRITE_SUPPORTED)
if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
#endif
#ifdef PNG_READ_SUPPORTED
... | [
1,
0
] |
Chromium | third_party/libpng/pngerror.c | void png_free_jmpbuf(png_structrp png_ptr) {
if (png_ptr != NULL) {
jmp_buf *jb = png_ptr->jmp_buf_ptr;
if (jb != NULL && png_ptr->jmp_buf_size > 0) {
/* This stuff is so that a failure to free the error control structure
* does not leave libpng in a state with no valid error handling: the
... | [
1,
0
] |
Chromium | third_party/libpng/pngerror.c | void PNGAPI png_set_strip_error_numbers(png_structrp png_ptr,
png_uint_32 strip_mode) {
if (png_ptr != NULL) {
png_ptr->flags &=
((~(PNG_FLAG_STRIP_ERROR_NUMBERS | PNG_FLAG_STRIP_ERROR_TEXT)) &
strip_mode);
}
}
#endif
#if defined(PNG_SIMPLIFIED_READ_SUPP... | [
0,
0
] |
Chromium | third_party/libpng/pngget.c |
size_t PNGAPI png_get_rowbytes(png_const_structrp png_ptr,
png_const_inforp info_ptr) {
if (png_ptr != NULL && info_ptr != NULL)
return (info_ptr->rowbytes);
return (0);
}
#ifdef PNG_INFO_IMAGE_SUPPORTED | [
1,
0
] |
Chromium | third_party/libpng/pngget.c | png_bytepp PNGAPI png_get_rows(png_const_structrp png_ptr,
png_const_inforp info_ptr) {
if (png_ptr != NULL && info_ptr != NULL)
return (info_ptr->row_pointers);
return (0);
}
#endif
#ifdef PNG_EASY_ACCESS_SUPPORTED | [
1,
0
] |
Chromium | third_party/libpng/pngget.c |
png_byte PNGAPI png_get_bit_depth(png_const_structrp png_ptr,
png_const_inforp info_ptr) {
if (png_ptr != NULL && info_ptr != NULL)
return info_ptr->bit_depth;
return (0);
} | [
1,
0
] |
Chromium | third_party/libpng/pngget.c |
png_uint_32 PNGAPI png_get_y_pixels_per_meter(png_const_structrp png_ptr,
png_const_inforp info_ptr) {
#ifdef PNG_pHYs_SUPPORTED
if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->valid & PNG_INFO_pHYs) != 0) {
png_debug1(1, "in %s retrieval function", "png_... | [
1,
0
] |
Chromium | third_party/libpng/pngget.c |
png_int_32 PNGAPI png_get_y_offset_microns(png_const_structrp png_ptr,
png_const_inforp info_ptr) {
#ifdef PNG_oFFs_SUPPORTED
if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->valid & PNG_INFO_oFFs) != 0) {
png_debug1(1, "in %s retrieval function", "png_get_y_... | [
1,
0
] |
Chromium | third_party/libpng/pngget.c |
png_uint_32 PNGAPI png_get_pixels_per_inch(png_const_structrp png_ptr,
png_const_inforp info_ptr) {
return ppi_from_ppm(png_get_pixels_per_meter(png_ptr, info_ptr));
} | [
0,
0
] |
Chromium | third_party/libpng/pngget.c |
png_fixed_point PNGAPI png_get_x_offset_inches_fixed(
png_const_structrp png_ptr, png_const_inforp info_ptr) {
return png_fixed_inches_from_microns(
png_ptr, png_get_x_offset_microns(png_ptr, info_ptr));
}
#endif
#ifdef PNG_FIXED_POINT_SUPPORTED | [
0,
0
] |
Chromium | third_party/libpng/pngget.c | png_fixed_point PNGAPI png_get_y_offset_inches_fixed(
png_const_structrp png_ptr, png_const_inforp info_ptr) {
return png_fixed_inches_from_microns(
png_ptr, png_get_y_offset_microns(png_ptr, info_ptr));
}
#endif
#ifdef PNG_FLOATING_POINT_SUPPORTED | [
0,
0
] |
Chromium | third_party/libpng/pngget.c | png_uint_32 PNGAPI png_get_gAMA_fixed(png_const_structrp png_ptr,
png_const_inforp info_ptr,
png_fixed_point *file_gamma) {
png_debug1(1, "in %s retrieval function", "gAMA");
if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->colo... | [
1,
0
] |
Chromium | third_party/libpng/pngget.c | int PNGAPI png_get_sPLT(png_const_structrp png_ptr, png_inforp info_ptr,
png_sPLT_tpp spalettes) {
if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL) {
*spalettes = info_ptr->splt_palettes;
return info_ptr->splt_palettes_num;
}
return (0);
}
#endif | [
1,
0
] |
Chromium | third_party/libpng/pngget.c | png_uint_32 PNGAPI png_get_hIST(png_const_structrp png_ptr, png_inforp info_ptr,
png_uint_16p *hist) {
png_debug1(1, "in %s retrieval function", "hIST");
if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->valid & PNG_INFO_hIST) != 0 && hist != NULL) {
*hist = info_ptr->... | [
1,
0
] |
Chromium | third_party/libpng/pngget.c | png_uint_32 PNGAPI png_get_oFFs(png_const_structrp png_ptr,
png_const_inforp info_ptr, png_int_32 *offset_x,
png_int_32 *offset_y, int *unit_type) {
png_debug1(1, "in %s retrieval function", "oFFs");
if (png_ptr != NULL && info_ptr != NULL &&
(i... | [
1,
0
] |
Chromium | third_party/libpng/pngget.c | png_uint_32 PNGAPI png_get_sCAL_fixed(png_const_structrp png_ptr,
png_const_inforp info_ptr, int *unit,
png_fixed_point *width,
png_fixed_point *height) {
if (png_ptr != NULL && info_ptr != NULL &&
... | [
1,
1
] |
Chromium | third_party/libpng/pngget.c | png_uint_32 PNGAPI png_get_sCAL(png_const_structrp png_ptr,
png_const_inforp info_ptr, int *unit,
double *width, double *height) {
if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->valid & PNG_INFO_sCAL) != 0) {
*unit = info_ptr->scal_unit;... | [
1,
0
] |
Chromium | third_party/libpng/pngget.c |
png_uint_32 PNGAPI png_get_PLTE(png_const_structrp png_ptr, png_inforp info_ptr,
png_colorp *palette, int *num_palette) {
png_debug1(1, "in %s retrieval function", "PLTE");
if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->valid & PNG_INFO_PLTE) != 0 && palette != NULL) {... | [
1,
0
] |
Chromium | third_party/libpng/pngget.c | png_uint_32 PNGAPI png_get_user_width_max(png_const_structrp png_ptr) {
return (png_ptr ? png_ptr->user_width_max : 0);
} | [
0,
0
] |
Chromium | third_party/libpng/pngget.c | png_alloc_size_t PNGAPI png_get_chunk_malloc_max(png_const_structrp png_ptr) {
return (png_ptr ? png_ptr->user_chunk_malloc_max : 0);
}
#endif
/* These functions were added to libpng 1.4.0 */
#ifdef PNG_IO_STATE_SUPPORTED | [
0,
0
] |
Chromium | third_party/libpng/pngmem.c | void PNGAPI png_free(png_const_structrp png_ptr, png_voidp ptr) {
if (png_ptr == NULL || ptr == NULL)
return;
#ifdef PNG_USER_MEM_SUPPORTED
if (png_ptr->free_fn != NULL)
png_ptr->free_fn(png_constcast(png_structrp, png_ptr), ptr);
else
png_free_default(png_ptr, ptr);
} | [
1,
0
] |
Chromium | third_party/libpng/pngmem.c | png_voidp PNGAPI png_get_mem_ptr(png_const_structrp png_ptr) {
if (png_ptr == NULL)
return NULL;
return png_ptr->mem_ptr;
}
#endif
#endif /* READ || WRITE */ | [
0,
0
] |
Chromium | third_party/libpng/pngpread.c | void png_process_some_data(png_structrp png_ptr, png_inforp info_ptr) {
if (png_ptr == NULL)
return;
switch (png_ptr->process_mode) {
case PNG_READ_SIG_MODE: {
png_push_read_sig(png_ptr, info_ptr);
break;
}
case PNG_READ_CHUNK_MODE: {
png_push_read_chunk(png_ptr, info_ptr);
break;
}
... | [
0,
0
] |
Chromium | third_party/libpng/pngpread.c |
void PNGCBAPI png_push_fill_buffer(png_structp png_ptr, png_bytep buffer,
size_t length) {
png_bytep ptr;
if (png_ptr == NULL)
return;
ptr = buffer;
if (png_ptr->save_buffer_size != 0) {
size_t save_size;
if (length < png_ptr->save_buffer_size)
save_size ... | [
1,
0
] |
Chromium | third_party/libpng/pngpread.c | void png_push_save_buffer(png_structrp png_ptr) {
if (png_ptr->save_buffer_size != 0) {
if (png_ptr->save_buffer_ptr != png_ptr->save_buffer) {
size_t i, istop;
png_bytep sp;
png_bytep dp;
istop = png_ptr->save_buffer_size;
for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->sa... | [
1,
0
] |
Chromium | third_party/libpng/pngpread.c | void png_push_restore_buffer(png_structrp png_ptr, png_bytep buffer,
size_t buffer_length) {
png_ptr->current_buffer = buffer;
png_ptr->current_buffer_size = buffer_length;
png_ptr->buffer_size = buffer_length + png_ptr->save_buffer_size;
png_ptr->current_buffer_ptr = png_ptr->curre... | [
0,
0
] |
Chromium | third_party/libpng/pngpread.c | void png_push_have_info(png_structrp png_ptr, png_inforp info_ptr) {
if (png_ptr->info_fn != NULL)
(*(png_ptr->info_fn))(png_ptr, info_ptr);
} | [
0,
0
] |
Chromium | third_party/libpng/pngpread.c | void png_push_have_end(png_structrp png_ptr, png_inforp info_ptr) {
if (png_ptr->end_fn != NULL)
(*(png_ptr->end_fn))(png_ptr, info_ptr);
} | [
0,
0
] |
Chromium | third_party/libpng/pngread.c | void PNGAPI png_read_rows(png_structrp png_ptr, png_bytepp row,
png_bytepp display_row, png_uint_32 num_rows) {
png_uint_32 i;
png_bytepp rp;
png_bytepp dp;
png_debug(1, "in png_read_rows");
if (png_ptr == NULL)
return;
rp = row;
dp = display_row;
if (rp != NULL && dp !=... | [
1,
0
] |
Chromium | third_party/libpng/pngread.c | static int png_image_read_init(png_imagep image) {
if (image->opaque == NULL) {
png_structp png_ptr = png_create_read_struct(
PNG_LIBPNG_VER_STRING, image, png_safe_error, png_safe_warning);
memset(image, 0, (sizeof *image));
image->version = PNG_IMAGE_VERSION;
if (png_ptr != NULL) {
p... | [
1,
0
] |
Chromium | third_party/libpng/pngread.c | static png_uint_32 png_image_format(png_structrp png_ptr) {
png_uint_32 format = 0;
if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
format |= PNG_FORMAT_FLAG_COLOR;
if ((png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0)
format |= PNG_FORMAT_FLAG_ALPHA;
else if (png_ptr->num_trans > 0)
form... | [
1,
0
] |
Chromium | third_party/libpng/pngread.c | int PNGAPI png_image_begin_read_from_file(png_imagep image,
const char *file_name) {
if (image != NULL && image->version == PNG_IMAGE_VERSION) {
if (file_name != NULL) {
FILE *fp = fopen(file_name, "rb");
if (fp != NULL) {
if (png_image_read_init(imag... | [
1,
0
] |
Chromium | third_party/libpng/pngread.c |
static void PNGCBAPI png_image_memory_read(png_structp png_ptr, png_bytep out,
size_t need) {
if (png_ptr != NULL) {
png_imagep image = png_voidcast(png_imagep, png_ptr->io_ptr);
if (image != NULL) {
png_controlp cp = image->opaque;
if (cp != NULL) {
... | [
1,
0
] |
Chromium | third_party/libpng/pngread.c | static void png_image_skip_unused_chunks(png_structrp png_ptr) {
{
static const png_byte chunks_to_process[] = {
98, 75, 71, 68, '\0', /* bKGD */
99, 72, 82, 77, '\0', /* cHRM */
103, 65, 77, 65, '\0', /* gAMA */
#ifdef PNG_READ_iCCP_SUPPORTED
105, 67, 67, 80, '\0', /* iCCP */
#... | [
0,
0
] |
Chromium | third_party/libpng/pngread.c | static void set_file_encoding(png_image_read_control *display) {
png_fixed_point g = display->image->opaque->png_ptr->colorspace.gamma;
if (png_gamma_significant(g) != 0) {
if (png_gamma_not_sRGB(g) != 0) {
display->file_encoding = P_FILE;
display->gamma_to_linear = png_reciprocal(g);
}
els... | [
1,
0
] |
Chromium | third_party/libpng/pngread.c | static unsigned int decode_gamma(png_image_read_control *display,
png_uint_32 value, int encoding) {
if (encoding == P_FILE)
encoding = display->file_encoding;
if (encoding == P_NOTSET) /* must be the file encoding */
{
set_file_encoding(display);
encoding = display->... | [
1,
0
] |
Chromium | third_party/libpng/pngread.c | static int make_rgb_colormap(png_image_read_control *display) {
unsigned int i, r;
for (i = r = 0; r < 6; ++r) {
unsigned int g;
for (g = 0; g < 6; ++g) {
unsigned int b;
for (b = 0; b < 6; ++b)
png_create_colormap_entry(display, i++, r * 51, g * 51, b * 51, 255,
... | [
0,
0
] |
Chromium | third_party/libpng/pngrio.c | void png_read_data(png_structrp png_ptr, png_bytep data, size_t length) {
png_debug1(4, "reading %d bytes", (int)length);
if (png_ptr->read_data_fn != NULL)
(*(png_ptr->read_data_fn))(png_ptr, data, length);
else
png_error(png_ptr, "Call to NULL read function");
} | [
1,
0
] |
Chromium | third_party/libpng/pngrtran.c | void PNGAPI png_set_crc_action(png_structrp png_ptr, int crit_action,
int ancil_action) {
png_debug(1, "in png_set_crc_action");
if (png_ptr == NULL)
return;
switch (crit_action) {
case PNG_CRC_NO_CHANGE: /* Leave setting as is */
break;
case PNG_CRC_WARN_USE: /* Warn... | [
0,
0
] |
Chromium | third_party/libpng/pngrtran.c | static int png_rtran_ok(png_structrp png_ptr, int need_IHDR) {
if (png_ptr != NULL) {
if ((png_ptr->flags & PNG_FLAG_ROW_INIT) != 0)
png_app_error(
png_ptr,
"invalid after png_start_read_image or png_read_update_info");
else if (need_IHDR && (png_ptr->mode & PNG_HAVE_IHDR) == 0)
... | [
1,
0
] |
Chromium | third_party/libpng/pngrtran.c | void PNGAPI png_set_strip_alpha(png_structrp png_ptr) {
png_debug(1, "in png_set_strip_alpha");
if (png_rtran_ok(png_ptr, 0) == 0)
return;
png_ptr->transformations |= PNG_STRIP_ALPHA;
}
#endif
#if defined(PNG_READ_ALPHA_MODE_SUPPORTED) || defined(PNG_READ_GAMMA_SUPPORTED) | [
0,
0
] |
Chromium | third_party/libpng/pngrtran.c | static png_fixed_point convert_gamma_value(png_structrp png_ptr,
double output_gamma) {
if (output_gamma > 0 && output_gamma < 128)
output_gamma *= PNG_FP_1;
/* This preserves -1 and -2 exactly: */
output_gamma = floor(output_gamma + .5);
if (output_gamma > PNG_... | [
1,
0
] |
Chromium | third_party/libpng/pngrtran.c | void PNGFAPI png_set_gamma_fixed(png_structrp png_ptr,
png_fixed_point scrn_gamma,
png_fixed_point file_gamma) {
png_debug(1, "in png_set_gamma_fixed");
if (png_rtran_ok(png_ptr, 0) == 0)
return;
scrn_gamma = translate_gamma_flags(png_ptr, sc... | [
0,
0
] |
Chromium | third_party/libpng/pngrtran.c | void PNGAPI png_set_gamma(png_structrp png_ptr, double scrn_gamma,
double file_gamma) {
png_set_gamma_fixed(png_ptr, convert_gamma_value(png_ptr, scrn_gamma),
convert_gamma_value(png_ptr, file_gamma));
}
#endif
#endif /* READ_GAMMA */
#ifdef PNG_READ_EXPAND_SUPPORTED | [
0,
0
] |
Chromium | third_party/libpng/pngrtran.c | void PNGAPI png_set_tRNS_to_alpha(png_structrp png_ptr) {
png_debug(1, "in png_set_tRNS_to_alpha");
if (png_rtran_ok(png_ptr, 0) == 0)
return;
png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
}
#endif
#ifdef PNG_READ_EXPAND_16_SUPPORTED | [
0,
0
] |
Chromium | third_party/libpng/pngrutil.c | static png_fixed_point png_get_fixed_point(png_structrp png_ptr,
png_const_bytep buf) {
png_uint_32 uval = png_get_uint_32(buf);
if (uval <= PNG_UINT_31_MAX)
return (png_fixed_point)uval;
/* The caller can turn off the warning by passing NULL. */
if (png_ptr != N... | [
0,
0
] |
Chromium | third_party/libpng/pngrutil.c | png_uint_32 png_read_chunk_header(png_structrp png_ptr) {
png_byte buf[8];
png_uint_32 length;
#ifdef PNG_IO_STATE_SUPPORTED
png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_HDR;
#endif
png_read_data(png_ptr, buf, 8);
length = png_get_uint_31(png_ptr, buf);
/* Put the chunk name into png_ptr->chunk_name... | [
0,
0
] |
Chromium | third_party/libpng/pngrutil.c | int png_zlib_inflate(png_structrp png_ptr, int flush) {
if (png_ptr->zstream_start && png_ptr->zstream.avail_in > 0) {
if ((*png_ptr->zstream.next_in >> 4) > 7) {
png_ptr->zstream.msg = "invalid window size (libpng)";
return Z_DATA_ERROR;
}
png_ptr->zstream_start = 0;
}
return inflate(&p... | [
1,
0
] |
Chromium | third_party/libpng/pngrutil.c | static int png_inflate_read(png_structrp png_ptr, png_bytep read_buffer,
uInt read_size, png_uint_32p chunk_bytes,
png_bytep next_out, png_alloc_size_t *out_size,
int finish) {
if (png_ptr->zowner == png_ptr->chunk_name) {
int ret... | [
0,
0
] |
Chromium | third_party/libpng/pngrutil.c | void png_handle_IEND(png_structrp png_ptr, png_inforp info_ptr,
png_uint_32 length) {
png_debug(1, "in png_handle_IEND");
if ((png_ptr->mode & PNG_HAVE_IHDR) == 0 ||
(png_ptr->mode & PNG_HAVE_IDAT) == 0)
png_chunk_error(png_ptr, "out of place");
png_ptr->mode |= (PNG_AFTER_IDAT | ... | [
0,
0
] |
Chromium | third_party/libpng/pngrutil.c | void png_handle_gAMA(png_structrp png_ptr, png_inforp info_ptr,
png_uint_32 length) {
png_fixed_point igamma;
png_byte buf[4];
png_debug(1, "in png_handle_gAMA");
if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
png_chunk_error(png_ptr, "missing IHDR");
else if ((png_ptr->mode & (PNG_HAVE... | [
0,
0
] |
Chromium | third_party/libpng/pngrutil.c | void png_handle_hIST(png_structrp png_ptr, png_inforp info_ptr,
png_uint_32 length) {
unsigned int num, i;
png_uint_16 readbuf[PNG_MAX_PALETTE_LENGTH];
png_debug(1, "in png_handle_hIST");
if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
png_chunk_error(png_ptr, "missing IHDR");
else if ((... | [
1,
0
] |
Chromium | third_party/libpng/pngrutil.c | void png_handle_tIME(png_structrp png_ptr, png_inforp info_ptr,
png_uint_32 length) {
png_byte buf[7];
png_time mod_time;
png_debug(1, "in png_handle_tIME");
if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
png_chunk_error(png_ptr, "missing IHDR");
else if (info_ptr != NULL && (info_ptr->... | [
1,
0
] |
Chromium | third_party/libpng/pngrutil.c | void png_check_chunk_length(png_const_structrp png_ptr, png_uint_32 length) {
png_alloc_size_t limit = PNG_UINT_31_MAX;
#ifdef PNG_SET_USER_LIMITS_SUPPORTED
if (png_ptr->user_chunk_malloc_max > 0 &&
png_ptr->user_chunk_malloc_max < limit)
limit = png_ptr->user_chunk_malloc_max;
#elif PNG_USER_CHUNK_MALLO... | [
1,
0
] |
Chromium | third_party/libpng/pngrutil.c |
static void png_read_filter_row_up(png_row_infop row_info, png_bytep row,
png_const_bytep prev_row) {
size_t i;
size_t istop = row_info->rowbytes;
png_bytep rp = row;
png_const_bytep pp = prev_row;
for (i = 0; i < istop; i++) {
*rp = (png_byte)(((int)(*rp) + (int)(*pp+... | [
0,
0
] |
Chromium | third_party/libpng/pngrutil.c | static void
png_read_filter_row_paeth_multibyte_pixel(png_row_infop row_info, png_bytep row,
png_const_bytep prev_row) {
unsigned int bpp = (row_info->pixel_depth + 7) >> 3;
png_bytep rp_end = row + bpp;
while (row < rp_end) {
int a = *row + *prev_row++;
*row++ =... | [
1,
0
] |
Chromium | third_party/libpng/pngrutil.c | void png_read_finish_IDAT(png_structrp png_ptr) {
if ((png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED) == 0) {
/* The NULL causes png_read_IDAT_data to swallow any remaining bytes in
* the compressed stream, but the stream may be damaged too, so even after
* this call we may need to terminate the zstream owne... | [
0,
0
] |
Chromium | third_party/libpng/pngset.c |
void PNGAPI png_set_cHRM_XYZ(png_const_structrp png_ptr, png_inforp info_ptr,
double red_X, double red_Y, double red_Z,
double green_X, double green_Y, double green_Z,
double blue_X, double blue_Y, double blue_Z) {
png_set_cHRM_XY... | [
0,
0
] |
Chromium | third_party/libpng/pngset.c | void PNGAPI png_set_PLTE(png_structrp png_ptr, png_inforp info_ptr,
png_const_colorp palette, int num_palette) {
png_uint_32 max_palette_length;
png_debug1(1, "in %s storage function", "PLTE");
if (png_ptr == NULL || info_ptr == NULL)
return;
max_palette_length = (info_ptr->colo... | [
1,
0
] |
Chromium | third_party/libpng/pngset.c | png_uint_32 PNGAPI png_permit_mng_features(png_structrp png_ptr,
png_uint_32 mng_features) {
png_debug(1, "in png_permit_mng_features");
if (png_ptr == NULL)
return 0;
png_ptr->mng_features_permitted = mng_features & PNG_ALL_MNG_FEATURES;
return png_ptr->mng_fea... | [
0,
0
] |
Chromium | third_party/libpng/pngset.c | static unsigned int add_one_chunk(png_bytep list, unsigned int count,
png_const_bytep add, int keep) {
unsigned int i;
for (i = 0; i < count; ++i, list += 5) {
if (memcmp(list, add, 4) == 0) {
list[4] = (png_byte)keep;
return count;
}
}
if (keep != PNG_HA... | [
1,
0
] |
Chromium | third_party/libpng/pngset.c | void PNGAPI png_set_chunk_cache_max(png_structrp png_ptr,
png_uint_32 user_chunk_cache_max) {
if (png_ptr != NULL)
png_ptr->user_chunk_cache_max = user_chunk_cache_max;
} | [
0,
0
] |
Chromium | third_party/libpng/pngtest.c | static void PNGCBAPI pngtest_error(png_structp png_ptr,
png_const_charp message) {
++error_count;
pngtest_warning(png_ptr, message);
}
/* END of code to validate stdio-free compilation */
/* START of code to validate memory allocation and deallocation */
#if defined(PNG_USER_ME... | [
0,
0
] |
Chromium | third_party/libpng/pngtrans.c | void PNGAPI png_set_bgr(png_structrp png_ptr) {
png_debug(1, "in png_set_bgr");
if (png_ptr == NULL)
return;
png_ptr->transformations |= PNG_BGR;
}
#endif | [
0,
0
] |
Chromium | third_party/libpng/pngtrans.c | void PNGAPI png_set_swap(png_structrp png_ptr) {
png_debug(1, "in png_set_swap");
if (png_ptr == NULL)
return;
if (png_ptr->bit_depth == 16)
png_ptr->transformations |= PNG_SWAP_BYTES;
} | [
0,
0
] |
Chromium | third_party/libpng/pngtrans.c | int PNGAPI png_set_interlace_handling(png_structrp png_ptr) {
png_debug(1, "in png_set_interlace handling");
if (png_ptr != 0 && png_ptr->interlaced != 0) {
png_ptr->transformations |= PNG_INTERLACE;
return (7);
}
return (1);
} | [
1,
0
] |
Chromium | third_party/libpng/pngtrans.c | void PNGAPI png_set_add_alpha(png_structrp png_ptr, png_uint_32 filler,
int filler_loc) {
png_debug(1, "in png_set_add_alpha");
if (png_ptr == NULL)
return;
png_set_filler(png_ptr, filler, filler_loc);
if ((png_ptr->transformations & PNG_FILLER) != 0)
png_ptr->transforma... | [
1,
0
] |
Chromium | third_party/libpng/pngtrans.c | void PNGAPI png_set_swap_alpha(png_structrp png_ptr) {
png_debug(1, "in png_set_swap_alpha");
if (png_ptr == NULL)
return;
png_ptr->transformations |= PNG_SWAP_ALPHA;
}
#endif
#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) | [
0,
0
] |
Chromium | third_party/libpng/pngtrans.c | void png_do_invert(png_row_infop row_info, png_bytep row) {
png_debug(1, "in png_do_invert");
if (row_info->color_type == PNG_COLOR_TYPE_GRAY) {
png_bytep rp = row;
size_t i;
size_t istop = row_info->rowbytes;
for (i = 0; i < istop; i++) {
*rp = (png_byte)(~(*rp));
rp++;
}
}
e... | [
0,
0
] |
Chromium | third_party/libpng/pngtrans.c | void png_do_swap(png_row_infop row_info, png_bytep row) {
png_debug(1, "in png_do_swap");
if (row_info->bit_depth == 16) {
png_bytep rp = row;
png_uint_32 i;
png_uint_32 istop = row_info->width * row_info->channels;
for (i = 0; i < istop; i++, rp += 2) {
#ifdef PNG_BUILTIN_BSWAP16_SUPPORTED
... | [
1,
0
] |
Chromium | third_party/libpng/pngtrans.c | png_byte PNGAPI png_get_current_pass_number(png_const_structrp png_ptr) {
if (png_ptr != NULL)
return png_ptr->pass;
return 8;
}
#endif /* USER_TRANSFORM_INFO */
#endif /* READ_USER_TRANSFORM || WRITE_USER_TRANSFORM */
#endif /* READ || WRITE */ | [
0,
0
] |
Chromium | third_party/libpng/pngwrite.c | void PNGAPI png_set_flush(png_structrp png_ptr, int nrows) {
png_debug(1, "in png_set_flush");
if (png_ptr == NULL)
return;
png_ptr->flush_dist = (nrows < 0 ? 0 : (png_uint_32)nrows);
} | [
0,
0
] |
Chromium | third_party/libpng/pngwrite.c | static void png_write_destroy(png_structrp png_ptr) {
png_debug(1, "in png_write_destroy");
if ((png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) != 0)
deflateEnd(&png_ptr->zstream);
/* Free our memory. png_free checks NULL for us. */
png_free_buffer_list(png_ptr, &png_ptr->zbuffer_list);
png_free(png_pt... | [
1,
0
] |
Chromium | third_party/libpng/pngwrite.c | void PNGAPI png_destroy_write_struct(png_structpp png_ptr_ptr,
png_infopp info_ptr_ptr) {
png_debug(1, "in png_destroy_write_struct");
if (png_ptr_ptr != NULL) {
png_structrp png_ptr = *png_ptr_ptr;
if (png_ptr != NULL) {
png_destroy_info_struct(png_ptr, info_ptr... | [
0,
0
] |
Chromium | third_party/libpng/pngwrite.c | void PNGAPI png_set_filter_heuristics(png_structrp png_ptr,
int heuristic_method, int num_weights,
png_const_doublep filter_weights,
png_const_doublep filter_costs) {
PNG_UNUSED(png_ptr)
PNG_UNUSED(heur... | [
0,
0
] |
Chromium | third_party/libpng/pngwrite.c |
void PNGAPI png_set_compression_mem_level(png_structrp png_ptr, int mem_level) {
png_debug(1, "in png_set_compression_mem_level");
if (png_ptr == NULL)
return;
png_ptr->zlib_mem_level = mem_level;
} | [
0,
0
] |
Chromium | third_party/libpng/pngwrite.c |
void PNGAPI png_set_text_compression_mem_level(png_structrp png_ptr,
int mem_level) {
png_debug(1, "in png_set_text_compression_mem_level");
if (png_ptr == NULL)
return;
png_ptr->zlib_text_mem_level = mem_level;
} | [
0,
0
] |
Chromium | third_party/libpng/pngwrite.c |
void PNGAPI png_set_text_compression_method(png_structrp png_ptr, int method) {
png_debug(1, "in png_set_text_compression_method");
if (png_ptr == NULL)
return;
if (method != 8)
png_warning(png_ptr, "Only compression method 8 is supported by PNG");
png_ptr->zlib_text_method = method;
} | [
0,
0
] |
Chromium | third_party/libpng/pngwrite.c | void PNGAPI png_set_write_status_fn(png_structrp png_ptr,
png_write_status_ptr write_row_fn) {
if (png_ptr == NULL)
return;
png_ptr->write_row_fn = write_row_fn;
}
#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED | [
0,
0
] |
Chromium | third_party/libpng/pngwrite.c | int PNGAPI png_image_write_to_memory(
png_imagep image, void *memory, png_alloc_size_t *PNG_RESTRICT memory_bytes,
int convert_to_8bit, const void *buffer, png_int_32 row_stride,
const void *colormap) {
if (image != NULL && image->version == PNG_IMAGE_VERSION) {
if (memory_bytes != NULL && buffer != ... | [
1,
0
] |
Chromium | third_party/libpng/pngwrite.c | int PNGAPI png_image_write_to_stdio(png_imagep image, FILE *file,
int convert_to_8bit, const void *buffer,
png_int_32 row_stride,
const void *colormap) {
if (image != NULL && image->version == PNG_IMAGE_VERSIO... | [
1,
0
] |
Chromium | third_party/libpng/pngwutil.c | void PNGAPI png_save_uint_32(png_bytep buf, png_uint_32 i) {
buf[0] = (png_byte)((i >> 24) & 0xffU);
buf[1] = (png_byte)((i >> 16) & 0xffU);
buf[2] = (png_byte)((i >> 8) & 0xffU);
buf[3] = (png_byte)(i & 0xffU);
} | [
0,
0
] |
Chromium | third_party/libpng/pngwutil.c | void PNGAPI png_write_chunk_data(png_structrp png_ptr, png_const_bytep data,
size_t length) {
if (png_ptr == NULL)
return;
if (data != NULL && length > 0) {
png_write_data(png_ptr, data, length);
/* Update the CRC after writing the data,
* in case the user I/O ro... | [
1,
0
] |
Chromium | third_party/libpng/pngwutil.c | void PNGAPI png_write_chunk(png_structrp png_ptr, png_const_bytep chunk_string,
png_const_bytep data, size_t length) {
png_write_complete_chunk(png_ptr, PNG_CHUNK_FROM_STRING(chunk_string), data,
length);
} | [
0,
0
] |
Chromium | third_party/libpng/pngwutil.c | * deflate header) to correct the windowBits value to match the actual data
* size. Note that the second argument is the *uncompressed* size but the
* first argument is the *compressed* data (and it must be deflate
* compressed.)
*/
static void
optimize_cmf(png_bytep data, png_alloc_size_t data_size... | [
1,
0
] |
Chromium | third_party/libpng/pngwutil.c | void png_write_IEND(png_structrp png_ptr) {
png_debug(1, "in png_write_IEND");
png_write_complete_chunk(png_ptr, png_IEND, NULL, 0);
png_ptr->mode |= PNG_HAVE_IEND;
}
#ifdef PNG_WRITE_gAMA_SUPPORTED | [
0,
0
] |
Chromium | third_party/libpng/pngwutil.c | void png_write_iCCP(png_structrp png_ptr, png_const_charp name,
png_const_bytep profile) {
png_uint_32 name_len;
png_uint_32 profile_len;
png_byte new_name[81];
compression_state comp;
png_uint_32 temp;
png_debug(1, "in png_write_iCCP");
/* These are all internal problems: the profil... | [
0,
0
] |
Chromium | third_party/libpng/pngwutil.c | void png_write_sBIT(png_structrp png_ptr, png_const_color_8p sbit,
int color_type) {
png_byte buf[4];
size_t size;
png_debug(1, "in png_write_sBIT");
if ((color_type & PNG_COLOR_MASK_COLOR) != 0) {
png_byte maxbits;
maxbits = (png_byte)(color_type == PNG_COLOR_TYPE_PALETTE
... | [
1,
0
] |
Chromium | third_party/libpng/pngwutil.c | void png_write_tRNS(png_structrp png_ptr, png_const_bytep trans_alpha,
png_const_color_16p tran, int num_trans, int color_type) {
png_byte buf[6];
png_debug(1, "in png_write_tRNS");
if (color_type == PNG_COLOR_TYPE_PALETTE) {
if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette) {... | [
1,
0
] |
Chromium | third_party/libpng/pngwutil.c | void png_write_zTXt(png_structrp png_ptr, png_const_charp key,
png_const_charp text, int compression) {
png_uint_32 key_len;
png_byte new_key[81];
compression_state comp;
png_debug(1, "in png_write_zTXt");
if (compression == PNG_TEXT_COMPRESSION_NONE) {
png_write_tEXt(png_ptr, key, t... | [
0,
0
] |
Chromium | third_party/libpng/pngwutil.c | void png_write_sCAL_s(png_structrp png_ptr, int unit, png_const_charp width,
png_const_charp height) {
png_byte buf[64];
size_t wlen, hlen, total_len;
png_debug(1, "in png_write_sCAL_s");
wlen = strlen(width);
hlen = strlen(height);
total_len = wlen + hlen + 2;
if (total_len > 64)... | [
1,
0
] |
Chromium | third_party/libpng/pngwutil.c | void png_write_tIME(png_structrp png_ptr, png_const_timep mod_time) {
png_byte buf[7];
png_debug(1, "in png_write_tIME");
if (mod_time->month > 12 || mod_time->month < 1 || mod_time->day > 31 ||
mod_time->day < 1 || mod_time->hour > 23 || mod_time->second > 60) {
png_warning(png_ptr, "Invalid time spe... | [
1,
0
] |
Chromium | third_party/libpng/pngwutil.c | static size_t png_setup_up_row(png_structrp png_ptr, size_t row_bytes,
size_t lmins) {
png_bytep rp, dp, pp;
size_t i;
size_t sum = 0;
unsigned int v;
png_ptr->try_row[0] = PNG_FILTER_VALUE_UP;
for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1,
pp = png_... | [
1,
0
] |
Chromium | third_party/libusb/src/libusb/core.c |
static struct discovered_devs *discovered_devs_alloc(void) {
struct discovered_devs *ret =
malloc(sizeof(*ret) + (sizeof(void *) * DISCOVERED_DEVICES_SIZE_STEP));
if (ret) {
ret->len = 0;
ret->capacity = DISCOVERED_DEVICES_SIZE_STEP;
}
return ret;
} | [
1,
0
] |
Chromium | third_party/libusb/src/libusb/core.c | struct libusb_device *usbi_alloc_device(struct libusb_context *ctx,
unsigned long session_id) {
size_t priv_size = usbi_backend->device_priv_size;
struct libusb_device *dev = calloc(1, sizeof(*dev) + priv_size);
int r;
if (!dev)
return NULL;
r = usbi_mutex_init(&d... | [
1,
0
] |
Chromium | third_party/libusb/src/libusb/core.c | void usbi_connect_device(struct libusb_device *dev) {
libusb_hotplug_message message;
ssize_t ret;
memset(&message, 0, sizeof(message));
message.event = LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED;
message.device = dev;
dev->attached = 1;
usbi_mutex_lock(&dev->ctx->usb_devs_lock);
list_add(&dev->list, &dev->c... | [
1,
0
] |
Chromium | third_party/libusb/src/libusb/core.c | void usbi_disconnect_device(struct libusb_device *dev) {
libusb_hotplug_message message;
struct libusb_context *ctx = dev->ctx;
ssize_t ret;
memset(&message, 0, sizeof(message));
message.event = LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT;
message.device = dev;
usbi_mutex_lock(&dev->lock);
dev->attached = 0;
us... | [
1,
0
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.