id stringlengths 22 26 | content stringlengths 72 142k |
|---|---|
devign_test_set_data_13149 | static void virtio_scsi_handle_cmd(VirtIODevice *vdev, VirtQueue *vq)
{
/* use non-QOM casts in the data path */
VirtIOSCSI *s = (VirtIOSCSI *)vdev;
VirtIOSCSICommon *vs = &s->parent_obj;
VirtIOSCSIReq *req;
int n;
while ((req = virtio_scsi_pop_req(s, vq))) {
SCSIDevice *d;
... |
devign_test_set_data_13154 | CharDriverState *text_console_init(QemuOpts *opts)
{
CharDriverState *chr;
QemuConsole *s;
unsigned width;
unsigned height;
chr = g_malloc0(sizeof(CharDriverState));
width = qemu_opt_get_number(opts, "width", 0);
if (width == 0)
width = qemu_opt_get_number(opts, "cols", ... |
devign_test_set_data_13155 | static uint64_t eepro100_read(void *opaque, target_phys_addr_t addr,
unsigned size)
{
EEPRO100State *s = opaque;
switch (size) {
case 1: return eepro100_read1(s, addr);
case 2: return eepro100_read2(s, addr);
case 4: return eepro100_read4(s, addr);
default... |
devign_test_set_data_13156 | bool vring_should_notify(VirtIODevice *vdev, Vring *vring)
{
uint16_t old, new;
bool v;
/* Flush out used index updates. This is paired
* with the barrier that the Guest executes when enabling
* interrupts. */
smp_mb();
if ((vdev->guest_features & (1 << VIRTIO_F_NOTIFY_ON_EMPTY))... |
devign_test_set_data_13163 | static int amr_nb_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
const AVFrame *frame, int *got_packet_ptr)
{
AMRContext *s = avctx->priv_data;
int written, ret;
int16_t *flush_buf = NULL;
const int16_t *samples = frame ? (const int16_t *)frame->data[0] : NULL;... |
devign_test_set_data_13172 | void do_unassigned_access(target_phys_addr_t addr, int is_write, int is_exec,
int is_asi, int size)
{
CPUState *saved_env;
/* XXX: hack to restore env in all cases, even if not called from
generated code */
saved_env = env;
env = cpu_single_env;
qemu_log("Una... |
devign_test_set_data_13204 | static int RENAME(swScale)(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
int srcSliceH, uint8_t* dst[], int dstStride[]){
/* load a few things into local vars to make the code more readable? and faster */
const int srcW= c->srcW;
const int dstW= c->dstW;
const int dstH= c->dstH;... |
devign_test_set_data_13205 | static inline void RENAME(bgr24ToY)(uint8_t *dst, const uint8_t *src, int width, uint32_t *unused)
{
#if COMPILE_TEMPLATE_MMX
RENAME(bgr24ToY_mmx)(dst, src, width, PIX_FMT_BGR24);
#else
int i;
for (i=0; i<width; i++) {
int b= src[i*3+0];
int g= src[i*3+1];
int r= src[i*3+2];... |
devign_test_set_data_13230 | void FUNC(ff_simple_idct)(DCTELEM *block)
{
int i;
for (i = 0; i < 8; i++)
FUNC(idctRowCondDC)(block + i*8);
for (i = 0; i < 8; i++)
FUNC(idctSparseCol)(block + i);
}
The vulnerability label is: Vulnerable |
devign_test_set_data_13236 | static void ohci_async_cancel_device(OHCIState *ohci, USBDevice *dev)
{
if (ohci->async_td &&
ohci->usb_packet.owner != NULL &&
ohci->usb_packet.owner->dev == dev) {
usb_cancel_packet(&ohci->usb_packet);
ohci->async_td = 0;
}
}
The vulnerability label is: Vulnerable |
devign_test_set_data_13268 | static int av_encode(AVFormatContext **output_files,
int nb_output_files,
AVFormatContext **input_files,
int nb_input_files,
AVStreamMap *stream_maps, int nb_stream_maps)
{
int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0... |
devign_test_set_data_13273 | int avpriv_mpeg4audio_get_config(MPEG4AudioConfig *c, const uint8_t *buf,
int bit_size, int sync_extension)
{
GetBitContext gb;
int specific_config_bitindex;
init_get_bits(&gb, buf, bit_size);
c->object_type = get_object_type(&gb);
c->sample_rate = get_sample_rate(&g... |
devign_test_set_data_13311 | static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
{
MpegEncContext *s = &v->s;
int mb_cbp = v->cbp[s->mb_x - 1 - s->mb_stride],
block_cbp = mb_cbp >> (block_num * 4), right_cbp,
mb_is_intra = v->is_intra[s->mb_x - 1 - s->mb_stride],
... |
devign_test_set_data_13316 | static int read_packet(AVFormatContext *s, uint8_t *buf, int raw_packet_size, uint8_t **data)
{
AVIOContext *pb = s->pb;
int len;
for(;;) {
len = ffio_read_indirect(pb, buf, TS_PACKET_SIZE, data);
if (len != TS_PACKET_SIZE)
return len < 0 ? len : AVERROR_EOF;
/*... |
devign_test_set_data_13339 | int ff_parse_sample_rate(unsigned *ret, const char *arg, void *log_ctx)
{
char *tail;
double srate = av_strtod(arg, &tail);
if (*tail || srate < 1 || (int)srate != srate) {
av_log(log_ctx, AV_LOG_ERROR, "Invalid sample rate '%s'\n", arg);
return AVERROR(EINVAL);
}
*ret = srat... |
devign_test_set_data_13347 | static void decode_abs_store(CPUTriCoreState *env, DisasContext *ctx)
{
int32_t op2;
int32_t r1;
uint32_t address;
TCGv temp;
r1 = MASK_OP_ABS_S1D(ctx->opcode);
address = MASK_OP_ABS_OFF18(ctx->opcode);
op2 = MASK_OP_ABS_OP2(ctx->opcode);
temp = tcg_const_i32(EA_ABS_FORMAT(a... |
devign_test_set_data_13357 | static void v9fs_readdir(void *opaque)
{
int32_t fid;
V9fsFidState *fidp;
ssize_t retval = 0;
size_t offset = 7;
uint64_t initial_offset;
int32_t count;
uint32_t max_count;
V9fsPDU *pdu = opaque;
V9fsState *s = pdu->s;
pdu_unmarshal(pdu, offset, "dqd", &fid, &initial... |
devign_test_set_data_13363 | uint64_t HELPER(lra)(CPUS390XState *env, uint64_t addr)
{
CPUState *cs = CPU(s390_env_get_cpu(env));
uint32_t cc = 0;
int old_exc = cs->exception_index;
uint64_t asc = env->psw.mask & PSW_MASK_ASC;
uint64_t ret;
int flags;
/* XXX incomplete - has more corner cases */
if (!(env... |
devign_test_set_data_13365 | static int bdrv_check_update_perm(BlockDriverState *bs, uint64_t new_used_perm,
uint64_t new_shared_perm,
BdrvChild *ignore_child, Error **errp)
{
BdrvChild *c;
uint64_t cumulative_perms = new_used_perm;
uint64_t cumulative_shared_per... |
devign_test_set_data_13366 | static void monitor_protocol_emitter(Monitor *mon, QObject *data)
{
QDict *qmp;
qmp = qdict_new();
if (!monitor_has_error(mon)) {
/* success response */
if (data) {
assert(qobject_type(data) == QTYPE_QDICT);
qobject_incref(data);
qdict_put_obj... |
devign_test_set_data_13388 | static inline int decode_vui_parameters(H264Context *h, SPS *sps)
{
int aspect_ratio_info_present_flag;
unsigned int aspect_ratio_idc;
aspect_ratio_info_present_flag = get_bits1(&h->gb);
if (aspect_ratio_info_present_flag) {
aspect_ratio_idc = get_bits(&h->gb, 8);
if (aspect_r... |
devign_test_set_data_13415 | int bdrv_write_compressed(BlockDriverState *bs, int64_t sector_num,
const uint8_t *buf, int nb_sectors)
{
BlockDriver *drv = bs->drv;
int ret;
if (!drv) {
return -ENOMEDIUM;
}
if (!drv->bdrv_write_compressed) {
return -ENOTSUP;
}
ret = b... |
devign_test_set_data_13426 | static int usb_host_handle_control(USBDevice *dev, USBPacket *p,
int request, int value, int index, int length, uint8_t *data)
{
USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
struct usbdevfs_urb *urb;
AsyncURB *aurb;
int ret;
/*
* Process certain standard devic... |
devign_test_set_data_13429 | static int dshow_read_header(AVFormatContext *avctx)
{
struct dshow_ctx *ctx = avctx->priv_data;
IGraphBuilder *graph = NULL;
ICreateDevEnum *devenum = NULL;
IMediaControl *control = NULL;
IMediaEvent *media_event = NULL;
HANDLE media_event_handle;
HANDLE proc;
int ret = AVERROR... |
devign_test_set_data_13437 | static inline void s390_machine_initfn(Object *obj)
{
object_property_add_bool(obj, "aes-key-wrap",
machine_get_aes_key_wrap,
machine_set_aes_key_wrap, NULL);
object_property_set_description(obj, "aes-key-wrap",
"enable/disable AES key ... |
devign_test_set_data_13442 | static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int nb_components, int predictor, int point_transform)
{
int i, mb_x, mb_y;
uint16_t (*buffer)[4];
int left[4], top[4], topleft[4];
const int linesize = s->linesize[0];
const int mask = ((1 << s->bits) - 1) << point_transform;
in... |
devign_test_set_data_13448 | static void qemu_spice_display_init_one(QemuConsole *con)
{
SimpleSpiceDisplay *ssd = g_new0(SimpleSpiceDisplay, 1);
qemu_spice_display_init_common(ssd);
ssd->qxl.base.sif = &dpy_interface.base;
qemu_spice_add_display_interface(&ssd->qxl, con);
assert(ssd->worker);
qemu_spice_create... |
devign_test_set_data_13462 | int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
int64_t wanted_timestamp, int flags)
{
int a, b, m;
int64_t timestamp;
a = -1;
b = nb_entries;
// Optimize appending index entries at the end.
if (b && entries[b - 1].timestamp < ... |
devign_test_set_data_13468 | static int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
{
InputStream *ist = s->opaque;
FrameBuffer *buf;
int ret, i;
if (!ist->buffer_pool && (ret = alloc_buffer(s, ist, &ist->buffer_pool)) < 0)
return ret;
buf = ist->buffer_pool;
ist->buffer_pool = buf->next;
bu... |
devign_test_set_data_13488 | static int filter_frame(AVFilterLink *inlink, AVFrame *inpic)
{
AVFilterContext *ctx = inlink->dst;
HisteqContext *histeq = ctx->priv;
AVFilterLink *outlink = ctx->outputs[0];
int strength = histeq->strength * 1000;
int intensity = histeq->intensity * 1000;
int x, y, i, ... |
devign_test_set_data_13494 | static void test_visitor_in_native_list_int32(TestInputVisitorData *data,
const void *unused)
{
test_native_list_integer_helper(data, unused,
USER_DEF_NATIVE_LIST_UNION_KIND_S32);
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_13504 | static void nbd_trip(void *opaque)
{
NBDClient *client = opaque;
NBDExport *exp = client->exp;
NBDRequest *req;
struct nbd_request request;
struct nbd_reply reply;
ssize_t ret;
uint32_t command;
TRACE("Reading request.");
if (client->closing) {
return;
}
... |
devign_test_set_data_13513 | void qemu_register_reset(QEMUResetHandler *func, void *opaque)
{
QEMUResetEntry *re = qemu_mallocz(sizeof(QEMUResetEntry));
re->func = func;
re->opaque = opaque;
TAILQ_INSERT_TAIL(&reset_handlers, re, entry);
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_13517 | void stl_phys_notdirty(hwaddr addr, uint32_t val)
{
uint8_t *ptr;
MemoryRegionSection *section;
section = phys_page_find(address_space_memory.dispatch, addr >> TARGET_PAGE_BITS);
if (!memory_region_is_ram(section->mr) || section->readonly) {
addr = memory_region_section_addr(section, a... |
devign_test_set_data_13524 | static void compute_antialias_float(MPADecodeContext *s,
GranuleDef *g)
{
float *ptr;
int n, i;
/* we antialias only "long" bands */
if (g->block_type == 2) {
if (!g->switch_point)
return;
/* XXX: check this for 8000Hz case */
... |
devign_test_set_data_13548 | PCIBus *i440fx_init(PCII440FXState **pi440fx_state, int *piix3_devfn, qemu_irq *pic, int ram_size)
{
DeviceState *dev;
PCIBus *b;
PCIDevice *d;
I440FXState *s;
PIIX3State *piix3;
dev = qdev_create(NULL, "i440FX-pcihost");
s = FROM_SYSBUS(I440FXState, sysbus_from_qdev(dev));
b ... |
devign_test_set_data_13554 | uint64_t helper_cvttq_c(CPUAlphaState *env, uint64_t a)
{
return inline_cvttq(env, a, float_round_to_zero, 0);
}
The vulnerability label is: Vulnerable |
devign_test_set_data_13555 | int ff_dca_core_parse(DCACoreDecoder *s, uint8_t *data, int size)
{
int ret;
s->ext_audio_mask = 0;
s->xch_pos = s->xxch_pos = s->x96_pos = 0;
if ((ret = init_get_bits8(&s->gb, data, size)) < 0)
return ret;
s->gb_in = s->gb;
if ((ret = parse_frame_header(s)) < 0)
r... |
devign_test_set_data_13556 | static void gen_mulu(DisasContext *dc, TCGv dest, TCGv srca, TCGv srcb)
{
TCGv sr_cy = tcg_temp_new();
tcg_gen_muls2_tl(dest, sr_cy, srca, srcb);
tcg_gen_setcondi_tl(TCG_COND_NE, sr_cy, sr_cy, 0);
tcg_gen_deposit_tl(cpu_sr, cpu_sr, sr_cy, ctz32(SR_CY), 1);
gen_ove_cy(dc, sr_cy);
tcg... |
devign_test_set_data_13571 | static int decode_init_mp3on4(AVCodecContext * avctx)
{
MP3On4DecodeContext *s = avctx->priv_data;
int i;
if ((avctx->extradata_size < 2) || (avctx->extradata == NULL)) {
av_log(avctx, AV_LOG_ERROR, "Codec extradata missing or too short.\n");
return -1;
}
s->chan_cfg = ((... |
devign_test_set_data_13589 | _syscall4(int,sys_utimensat,int,dirfd,const char *,pathname,
const struct timespec *,tsp,int,flags)
#endif
#endif /* CONFIG_UTIMENSAT */
#ifdef CONFIG_INOTIFY
#include <sys/inotify.h>
#if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
static int sys_inotify_init(void)
{
return (... |
devign_test_set_data_13604 | static void curl_readv_bh_cb(void *p)
{
CURLState *state;
int running;
CURLAIOCB *acb = p;
BDRVCURLState *s = acb->common.bs->opaque;
qemu_bh_delete(acb->bh);
acb->bh = NULL;
size_t start = acb->sector_num * SECTOR_SIZE;
size_t end;
// In case we have the requested ... |
devign_test_set_data_13635 | static int dnxhd_encode_rdo(AVCodecContext *avctx, DNXHDEncContext *ctx)
{
int lambda, up_step, down_step;
int last_lower = INT_MAX, last_higher = 0;
int x, y, q;
for (q = 1; q < avctx->qmax; q++) {
ctx->qscale = q;
avctx->execute2(avctx, dnxhd_calc_bits_thread, NULL, NULL, ctx-... |
devign_test_set_data_13636 | static int find_and_decode_index(NUTContext *nut)
{
AVFormatContext *s = nut->avf;
AVIOContext *bc = s->pb;
uint64_t tmp, end;
int i, j, syncpoint_count;
int64_t filesize = avio_size(bc);
int64_t *syncpoints;
int8_t *has_keyframe;
int ret = AVERROR_INVALIDDATA;
avio_se... |
devign_test_set_data_13667 | static inline void menelaus_rtc_stop(struct menelaus_s *s)
{
qemu_del_timer(s->rtc.hz);
s->rtc.next =- qemu_get_clock(rt_clock);
if (s->rtc.next < 1)
s->rtc.next = 1;
}
The vulnerability label is: Vulnerable |
devign_test_set_data_13672 | int drive_init(struct drive_opt *arg, int snapshot, void *opaque)
{
char buf[128];
char file[1024];
char devname[128];
char serial[21];
const char *mediastr = "";
BlockInterfaceType type;
enum { MEDIA_DISK, MEDIA_CDROM } media;
int bus_id, unit_id;
int cyls, heads, secs, tr... |
devign_test_set_data_13706 | static void gic_complete_irq(gic_state * s, int cpu, int irq)
{
int update = 0;
int cm = 1 << cpu;
DPRINTF("EOI %d\n", irq);
if (s->running_irq[cpu] == 1023)
return; /* No active IRQ. */
if (irq != 1023) {
/* Mark level triggered interrupts as pending if they are still
... |
devign_test_set_data_13712 | static void init_dequant8_coeff_table(H264Context *h){
int i,q,x;
const int transpose = (h->h264dsp.h264_idct8_add != ff_h264_idct8_add_c); //FIXME ugly
h->dequant8_coeff[0] = h->dequant8_buffer[0];
h->dequant8_coeff[1] = h->dequant8_buffer[1];
for(i=0; i<2; i++ ){
if(i && !memcmp(h-... |
devign_test_set_data_13726 | char *vnc_display_local_addr(const char *id)
{
VncDisplay *vs = vnc_display_find(id);
return vnc_socket_local_addr("%s:%s", vs->lsock);
}
The vulnerability label is: Vulnerable |
devign_test_set_data_13728 | PPC_OP(set_T0)
{
T0 = PARAM(1);
RETURN();
}
The vulnerability label is: Vulnerable |
devign_test_set_data_13734 | static void test_validate_fail_struct_nested(TestInputVisitorData *data,
const void *unused)
{
UserDefTwo *udp = NULL;
Error *err = NULL;
Visitor *v;
v = validate_test_init(data, "{ 'string0': 'string0', 'dict1': { 'string1': 'string1', 'dict2': { 'u... |
devign_test_set_data_13736 | static int socket_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
{
QEMUFileSocket *s = opaque;
ssize_t len;
do {
len = qemu_recv(s->fd, buf, size, 0);
} while (len == -1 && socket_error() == EINTR);
if (len == -1)
len = -socket_error();
return len;
... |
devign_test_set_data_13739 | static GIOStatus ga_channel_write(GAChannel *c, const char *buf, size_t size,
size_t *count)
{
GIOStatus status;
OVERLAPPED ov = {0};
BOOL ret;
DWORD written;
ov.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
ret = WriteFile(c->handle, buf, size, &wri... |
devign_test_set_data_13740 | int ff_jni_exception_get_summary(JNIEnv *env, jthrowable exception, char **error, void *log_ctx)
{
int ret = 0;
AVBPrint bp;
char *name = NULL;
char *message = NULL;
jclass class_class = NULL;
jmethodID get_name_id = NULL;
jclass exception_class = NULL;
jmethodID get_mes... |
devign_test_set_data_13748 | static void vscsi_command_complete(SCSIBus *bus, int reason, uint32_t tag,
uint32_t arg)
{
VSCSIState *s = DO_UPCAST(VSCSIState, vdev.qdev, bus->qbus.parent);
vscsi_req *req = vscsi_find_req(s, tag);
SCSIDevice *sdev;
uint8_t *buf;
int32_t res_in = 0, res_ou... |
devign_test_set_data_13754 | void helper_store_sdr1(CPUPPCState *env, target_ulong val)
{
PowerPCCPU *cpu = ppc_env_get_cpu(env);
if (!env->external_htab) {
if (env->spr[SPR_SDR1] != val) {
ppc_store_sdr1(env, val);
tlb_flush(CPU(cpu));
}
}
}
The vulnerability label is: Non-vulnerabl... |
devign_test_set_data_13768 | static bool fw_cfg_comb_valid(void *opaque, target_phys_addr_t addr,
unsigned size, bool is_write)
{
return (size == 1) || (is_write && size == 2);
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_13772 | sPAPRTCETable *spapr_tce_new_table(DeviceState *owner, uint32_t liobn,
uint64_t bus_offset,
uint32_t page_shift,
uint32_t nb_table,
bool vfio_accel)
{
sPAPRTCETable *tcet... |
devign_test_set_data_13784 | static void debug_print_fis(uint8_t *fis, int cmd_len)
{
#ifdef DEBUG_AHCI
int i;
fprintf(stderr, "fis:");
for (i = 0; i < cmd_len; i++) {
if ((i & 0xf) == 0) {
fprintf(stderr, "\n%02x:",i);
}
fprintf(stderr, "%02x ",fis[i]);
}
fprintf(stderr, "\n");
... |
devign_test_set_data_13809 | static av_cold int svc_encode_init(AVCodecContext *avctx)
{
SVCContext *s = avctx->priv_data;
SEncParamExt param = { 0 };
int err = AVERROR_UNKNOWN;
int log_level;
WelsTraceCallback callback_function;
AVCPBProperties *props;
// Mingw GCC < 4.7 on x86_32 uses an incorrect/buggy ABI ... |
devign_test_set_data_13829 | static void sm501_disp_ctrl_write(void *opaque, hwaddr addr,
uint64_t value, unsigned size)
{
SM501State *s = (SM501State *)opaque;
SM501_DPRINTF("sm501 disp ctrl regs : write addr=%x, val=%x\n",
(unsigned)addr, (unsigned)value);
switch (addr) {
... |
devign_test_set_data_13855 | void rgb15to16(const uint8_t *src,uint8_t *dst,uint32_t src_size)
{
#ifdef HAVE_MMX
register const char* s=src+src_size;
register char* d=dst+src_size;
register int offs=-src_size;
__asm __volatile(PREFETCH" %0"::"m"(*(s+offs)):"memory");
__asm __volatile(
"movq %0, %%mm4\n\t"
"movq %1, %%mm5"
::... |
devign_test_set_data_13859 | static int rle_unpack(const unsigned char *src, unsigned char *dest,
int src_len, int dest_len)
{
const unsigned char *ps;
unsigned char *pd;
int i, l;
unsigned char *dest_end = dest + dest_len;
ps = src;
pd = dest;
if (src_len & 1)
*pd++ = *ps++;
src_len >>= 1... |
devign_test_set_data_13867 | void ff_avg_h264_qpel16_mc33_msa(uint8_t *dst, const uint8_t *src,
ptrdiff_t stride)
{
avc_luma_hv_qrt_and_aver_dst_16x16_msa(src + stride - 2,
src - (stride * 2) +
sizeof(uint8_t), stride,
... |
devign_test_set_data_13888 | static int vorbis_parse(AVCodecParserContext *s1, AVCodecContext *avctx,
const uint8_t **poutbuf, int *poutbuf_size,
const uint8_t *buf, int buf_size)
{
VorbisParseContext *s = s1->priv_data;
int duration;
if (!s->vp && avctx->extradata && avctx->extra... |
devign_test_set_data_13890 | static void xen_ram_init(PCMachineState *pcms,
ram_addr_t ram_size, MemoryRegion **ram_memory_p)
{
MemoryRegion *sysmem = get_system_memory();
ram_addr_t block_len;
uint64_t user_lowmem = object_property_get_int(qdev_get_machine(),
... |
devign_test_set_data_13897 | static void pci_spapr_set_irq(void *opaque, int irq_num, int level)
{
/*
* Here we use the number returned by pci_spapr_map_irq to find a
* corresponding qemu_irq.
*/
sPAPRPHBState *phb = opaque;
trace_spapr_pci_lsi_set(phb->busname, irq_num, phb->lsi_table[irq_num].irq);
qemu_s... |
devign_test_set_data_13899 | static int alloc_sequence_buffers(DiracContext *s)
{
int sbwidth = DIVRNDUP(s->source.width, 4);
int sbheight = DIVRNDUP(s->source.height, 4);
int i, w, h, top_padding;
/* todo: think more about this / use or set Plane here */
for (i = 0; i < 3; i++) {
int max_xblen = MAX_BLOCKSIZ... |
devign_test_set_data_13905 | static int hevc_handle_packet(AVFormatContext *ctx, PayloadContext *rtp_hevc_ctx,
AVStream *st, AVPacket *pkt, uint32_t *timestamp,
const uint8_t *buf, int len, uint16_t seq,
int flags)
{
const uint8_t *rtp_pl = buf;
... |
devign_test_set_data_13906 | int avpriv_lock_avformat(void)
{
if (lockmgr_cb) {
if ((*lockmgr_cb)(&avformat_mutex, AV_LOCK_OBTAIN))
return -1;
}
return 0;
}
The vulnerability label is: Vulnerable |
devign_test_set_data_13915 | static int libschroedinger_encode_close(AVCodecContext *avctx)
{
SchroEncoderParams *p_schro_params = avctx->priv_data;
/* Close the encoder. */
schro_encoder_free(p_schro_params->encoder);
/* Free data in the output frame queue. */
ff_schro_queue_free(&p_schro_params->enc_frame_queue,
... |
devign_test_set_data_13943 | static int cinepak_decode_frame(AVCodecContext *avctx,
void *data, int *got_frame,
AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int ret = 0, buf_size = avpkt->size;
CinepakContext *s = avctx->priv_data;
s->data = buf;
... |
devign_test_set_data_13951 | static void taihu_405ep_init(MachineState *machine)
{
ram_addr_t ram_size = machine->ram_size;
const char *kernel_filename = machine->kernel_filename;
const char *initrd_filename = machine->initrd_filename;
char *filename;
qemu_irq *pic;
MemoryRegion *sysmem = get_system_memory();
Me... |
devign_test_set_data_13969 | static void *ff_avio_child_next(void *obj, void *prev)
{
AVIOContext *s = obj;
AVIOInternal *internal = s->opaque;
return prev ? NULL : internal->h;
}
The vulnerability label is: Vulnerable |
devign_test_set_data_13988 | static void pm_ioport_read(IORange *ioport, uint64_t addr, unsigned width,
uint64_t *data)
{
PIIX4PMState *s = container_of(ioport, PIIX4PMState, ioport);
uint32_t val;
switch(addr) {
case 0x00:
val = acpi_pm1_evt_get_sts(&s->ar, s->ar.tmr.overflow_time);
... |
devign_test_set_data_14014 | static int update_dimensions(VP8Context *s, int width, int height)
{
if (width != s->avctx->width ||
height != s->avctx->height) {
if (av_image_check_size(width, height, 0, s->avctx))
return AVERROR_INVALIDDATA;
vp8_decode_flush_impl(s->avctx, 1, 0, 1);
avcode... |
devign_test_set_data_14022 | int nbd_receive_reply(QIOChannel *ioc, NBDReply *reply, Error **errp)
{
int ret;
const char *type;
ret = nbd_read_eof(ioc, &reply->magic, sizeof(reply->magic), errp);
if (ret <= 0) {
return ret;
}
be32_to_cpus(&reply->magic);
switch (reply->magic) {
case NBD_SIMPL... |
devign_test_set_data_14023 | static void ne2000_receive(void *opaque, const uint8_t *buf, int size)
{
NE2000State *s = opaque;
uint8_t *p;
int total_len, next, avail, len, index, mcast_idx;
uint8_t buf1[60];
static const uint8_t broadcast_macaddr[6] =
{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
#if defined(DE... |
devign_test_set_data_14024 | static void truespeech_apply_twopoint_filter(TSContext *dec, int quart)
{
int16_t tmp[146 + 60], *ptr0, *ptr1;
const int16_t *filter;
int i, t, off;
t = dec->offset2[quart];
if(t == 127){
memset(dec->newvec, 0, 60 * sizeof(*dec->newvec));
return;
}
for(i = 0; i < ... |
devign_test_set_data_14025 | static void scsi_disk_purge_requests(SCSIDiskState *s)
{
SCSIDiskReq *r;
while (!QTAILQ_EMPTY(&s->qdev.requests)) {
r = DO_UPCAST(SCSIDiskReq, req, QTAILQ_FIRST(&s->qdev.requests));
if (r->req.aiocb) {
bdrv_aio_cancel(r->req.aiocb);
}
scsi_remove_request(r);... |
devign_test_set_data_14031 | static int net_slirp_init(VLANState *vlan)
{
if (!slirp_inited) {
slirp_inited = 1;
slirp_init();
}
slirp_vc = qemu_new_vlan_client(vlan,
slirp_receive, NULL);
snprintf(slirp_vc->info_str, sizeof(slirp_vc->info_str), "user redirector");
r... |
devign_test_set_data_14056 | static int pnm_decode_header(AVCodecContext *avctx, PNMContext * const s){
char buf1[32], tuple_type[32];
int h, w, depth, maxval;;
pnm_get(s, buf1, sizeof(buf1));
if (!strcmp(buf1, "P4")) {
avctx->pix_fmt = PIX_FMT_MONOWHITE;
} else if (!strcmp(buf1, "P5")) {
if (avctx->cod... |
devign_test_set_data_14076 | void cpu_physical_memory_rw(target_phys_addr_t addr, uint8_t *buf,
int len, int is_write)
{
return address_space_rw(&address_space_memory, addr, buf, len, is_write);
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_14090 | static void v9fs_link(void *opaque)
{
V9fsPDU *pdu = opaque;
V9fsState *s = pdu->s;
int32_t dfid, oldfid;
V9fsFidState *dfidp, *oldfidp;
V9fsString name;
size_t offset = 7;
int err = 0;
pdu_unmarshal(pdu, offset, "dds", &dfid, &oldfid, &name);
trace_v9fs_link(pdu->tag, pd... |
devign_test_set_data_14108 | int dxva2_init(AVCodecContext *s)
{
InputStream *ist = s->opaque;
int loglevel = (ist->hwaccel_id == HWACCEL_AUTO) ? AV_LOG_VERBOSE : AV_LOG_ERROR;
DXVA2Context *ctx;
int ret;
if (!ist->hwaccel_ctx) {
ret = dxva2_alloc(s);
if (ret < 0)
return ret;
}
c... |
devign_test_set_data_14126 | static XenPTBarFlag xen_pt_bar_reg_parse(XenPCIPassthroughState *s,
XenPTRegInfo *reg)
{
PCIDevice *d = &s->dev;
XenPTRegion *region = NULL;
PCIIORegion *r;
int index = 0;
/* check 64bit BAR */
index = xen_pt_bar_offset_to_index(reg->offset);
... |
devign_test_set_data_14141 | static av_cold int g726_encode_init(AVCodecContext *avctx)
{
G726Context* c = avctx->priv_data;
if (avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL &&
avctx->sample_rate != 8000) {
av_log(avctx, AV_LOG_ERROR, "Sample rates other than 8kHz are not "
"allowed when th... |
devign_test_set_data_14144 | static int dv_read_seek(AVFormatContext *s, int stream_index,
int64_t timestamp, int flags)
{
RawDVContext *r = s->priv_data;
DVDemuxContext *c = r->dv_demux;
int64_t offset = dv_frame_offset(s, c, timestamp, flags);
dv_offset_reset(c, offset / c->sys->frame_size);
... |
devign_test_set_data_14162 | static void spapr_phb_hot_plug_child(HotplugHandler *plug_handler,
DeviceState *plugged_dev, Error **errp)
{
sPAPRPHBState *phb = SPAPR_PCI_HOST_BRIDGE(DEVICE(plug_handler));
PCIDevice *pdev = PCI_DEVICE(plugged_dev);
sPAPRDRConnector *drc = spapr_phb_get_pci_drc(ph... |
devign_test_set_data_14168 | av_cold int ff_dvvideo_init(AVCodecContext *avctx)
{
DVVideoContext *s = avctx->priv_data;
DSPContext dsp;
static int done = 0;
int i, j;
if (!done) {
VLC dv_vlc;
uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
uint8_t new_dv_vlc_len[NB_DV_VLC*2];
uint8_t new_dv_... |
devign_test_set_data_14199 | static int libquvi_read_header(AVFormatContext *s)
{
int i, ret;
quvi_t q;
quvi_media_t m;
QUVIcode rc;
LibQuviContext *qc = s->priv_data;
char *media_url, *pagetitle;
rc = quvi_init(&q);
if (rc != QUVI_OK)
goto quvi_fail;
quvi_setopt(q, QUVIOPT_FORMAT, qc->for... |
devign_test_set_data_14220 | static int add_old_style_options(const char *fmt, QemuOpts *opts,
const char *base_filename,
const char *base_fmt)
{
if (base_filename) {
if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename)) {
error_report("Backing... |
devign_test_set_data_14228 | void qemu_flush_queued_packets(VLANClientState *vc)
{
while (!TAILQ_EMPTY(&vc->vlan->send_queue)) {
VLANPacket *packet;
int ret;
packet = TAILQ_FIRST(&vc->vlan->send_queue);
TAILQ_REMOVE(&vc->vlan->send_queue, packet, entry);
ret = qemu_deliver_packet(packet->sende... |
devign_test_set_data_14248 | LF_FUNC (h, luma, sse2)
LF_IFUNC(h, luma_intra, sse2)
LF_FUNC (v, luma, sse2)
LF_IFUNC(v, luma_intra, sse2)
/***********************************/
/* weighted prediction */
#define H264_WEIGHT(W, H, OPT) \
void ff_h264_weight_ ## W ## x ## H ## _ ## OPT(uint8_t *dst, \
int stride,... |
devign_test_set_data_14263 | static int decode_band_hdr(IVI45DecContext *ctx, IVIBandDesc *band,
AVCodecContext *avctx)
{
int plane, band_num, indx, transform_id, scan_indx;
int i;
plane = get_bits(&ctx->gb, 2);
band_num = get_bits(&ctx->gb, 4);
if (band->plane != plane || band->band_num !... |
devign_test_set_data_14289 | long do_syscall(void *cpu_env, int num, long arg1, long arg2, long arg3,
long arg4, long arg5, long arg6)
{
long ret;
struct stat st;
struct kernel_statfs *stfs;
#ifdef DEBUG
gemu_log("syscall %d\n", num);
#endif
switch(num) {
case TARGET_NR_exit:
#ifdef HAVE_GP... |
devign_test_set_data_14300 | static int rebuild_refcount_structure(BlockDriverState *bs,
BdrvCheckResult *res,
void **refcount_table,
int64_t *nb_clusters)
{
BDRVQcow2State *s = bs->opaque;
int64_t first_free_cluster = 0,... |
devign_test_set_data_14306 | static int synchronize_audio(VideoState *is, short *samples,
int samples_size1, double pts)
{
int n, samples_size;
double ref_clock;
n = 2 * is->audio_st->codec->channels;
samples_size = samples_size1;
/* if not master, then we try to remove or add samples to ... |
devign_test_set_data_14308 | av_cold int ff_ivi_init_planes(IVIPlaneDesc *planes, const IVIPicConfig *cfg,
int is_indeo4)
{
int p, b;
uint32_t b_width, b_height, align_fac, width_aligned,
height_aligned, buf_size;
IVIBandDesc *band;
ivi_free_buffers(planes);
if (av_image_c... |
devign_test_set_data_14309 | static av_cold int seqvideo_decode_init(AVCodecContext *avctx)
{
SeqVideoContext *seq = avctx->priv_data;
seq->avctx = avctx;
avctx->pix_fmt = AV_PIX_FMT_PAL8;
seq->frame = av_frame_alloc();
if (!seq->frame)
return AVERROR(ENOMEM);
return 0;
}
The vulnerability label is: Vulnerable |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.