id int32 0 27.3k | func stringlengths 26 142k | target bool 2
classes | project stringclasses 2
values | commit_id stringlengths 40 40 |
|---|---|---|---|---|
6,834 | uint32_t HELPER(mvcl)(CPUS390XState *env, uint32_t r1, uint32_t r2)
{
uintptr_t ra = GETPC();
uint64_t destlen = env->regs[r1 + 1] & 0xffffff;
uint64_t dest = get_address(env, r1);
uint64_t srclen = env->regs[r2 + 1] & 0xffffff;
uint64_t src = get_address(env, r2);
uint8_t pad = env->regs... | false | qemu | d33271213437ed1834b0a50540d79e877e1cd894 |
6,836 | static int do_compress_ram_page(CompressParam *param)
{
int bytes_sent, blen;
uint8_t *p;
RAMBlock *block = param->block;
ram_addr_t offset = param->offset;
p = block->host + (offset & TARGET_PAGE_MASK);
bytes_sent = save_page_header(param->file, block, offset |
... | false | qemu | b3be28969b797b27d7f7f806827e9898e4ee08f0 |
6,837 | static int get_fw_cfg_order(FWCfgState *s, const char *name)
{
int i;
if (s->fw_cfg_order_override > 0) {
return s->fw_cfg_order_override;
}
for (i = 0; i < ARRAY_SIZE(fw_cfg_order); i++) {
if (fw_cfg_order[i].name == NULL) {
continue;
}
if (st... | false | qemu | 3dc6f8693694a649a9c83f1e2746565b47683923 |
6,840 | int qemu_strtol(const char *nptr, const char **endptr, int base,
long *result)
{
char *ep;
int err = 0;
if (!nptr) {
if (endptr) {
*endptr = nptr;
}
err = -EINVAL;
} else {
errno = 0;
*result = strtol(nptr, &ep, base);
... | false | qemu | 4baef2679e029c76707be1e2ed54bf3dd21693fe |
6,841 | void ff_sbr_apply(AACContext *ac, SpectralBandReplication *sbr, int id_aac,
float* L, float* R)
{
int downsampled = ac->m4ac.ext_sample_rate < sbr->sample_rate;
int ch;
int nch = (id_aac == TYPE_CPE) ? 2 : 1;
if (sbr->start) {
sbr_dequant(sbr, id_aac);
}
for ... | false | FFmpeg | aac46e088d67a390489af686b846dea4987d8ffb |
6,842 | static void stellaris_enet_receive(void *opaque, const uint8_t *buf, size_t size)
{
stellaris_enet_state *s = (stellaris_enet_state *)opaque;
int n;
uint8_t *p;
uint32_t crc;
if ((s->rctl & SE_RCTL_RXEN) == 0)
return;
if (s->np >= 31) {
DPRINTF("Packet dropped\n");
... | false | qemu | e3f5ec2b5e92706e3b807059f79b1fb5d936e567 |
6,843 | static void virtio_blk_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
k->init = virtio_blk_init_pci;
k->exit = virtio_blk_exit_pci;
k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
k->device_id = PCI_DEVICE_I... | false | qemu | 6acbe4c6f18e7de00481ff30574262b58526de45 |
6,845 | static void qxl_dirty_surfaces(PCIQXLDevice *qxl)
{
uintptr_t vram_start;
int i;
if (qxl->mode != QXL_MODE_NATIVE && qxl->mode != QXL_MODE_COMPAT) {
return;
}
/* dirty the primary surface */
qxl_set_dirty(&qxl->vga.vram, qxl->shadow_rom.draw_area_offset,
qx... | false | qemu | 1331eab216c9dc4e50a48a34d14926b31a7fd611 |
6,846 | static void xics_reset(DeviceState *d)
{
XICSState *icp = XICS(d);
int i;
for (i = 0; i < icp->nr_servers; i++) {
device_reset(DEVICE(&icp->ss[i]));
}
device_reset(DEVICE(icp->ics));
}
| false | qemu | 5a3d7b23ba41b4884b43b6bc936ea18f999d5c6b |
6,847 | void spapr_drc_attach(sPAPRDRConnector *drc, DeviceState *d, void *fdt,
int fdt_start_offset, bool coldplug, Error **errp)
{
trace_spapr_drc_attach(spapr_drc_index(drc));
if (drc->isolation_state != SPAPR_DR_ISOLATION_STATE_ISOLATED) {
error_setg(errp, "an attached device is... | false | qemu | 307b7715d0256c95444cada36a02882e46bada2f |
6,848 | static void openpic_src_write(void *opaque, hwaddr addr, uint64_t val,
unsigned len)
{
OpenPICState *opp = opaque;
int idx;
DPRINTF("%s: addr %#" HWADDR_PRIx " <= %08" PRIx64 "\n",
__func__, addr, val);
if (addr & 0xF) {
return;
}
add... | false | qemu | e0dfe5b18919a6a4deb841dcf3212e3e998c95e5 |
6,849 | static void gen_exception_internal_insn(DisasContext *s, int offset, int excp)
{
gen_set_condexec(s);
gen_set_pc_im(s, s->pc - offset);
gen_exception_internal(excp);
s->is_jmp = DISAS_JUMP;
}
| false | qemu | 8a6b28c7b5104263344508df0f4bce97f22cfcaf |
6,850 | static void gen_thumb2_parallel_addsub(int op1, int op2, TCGv a, TCGv b)
{
TCGv tmp;
switch (op1) {
#define gen_pas_helper(name) glue(gen_helper_,name)(a, a, b, tmp)
case 0:
tmp = tcg_temp_new(TCG_TYPE_PTR);
tcg_gen_addi_ptr(tmp, cpu_env, offsetof(CPUState, GE));
PAS_OP(s)
... | false | qemu | a7812ae412311d7d47f8aa85656faadac9d64b56 |
6,851 | static void test_io_rw_interface(enum AddrMode lba48, enum IOMode dma,
unsigned bufsize, uint64_t sector)
{
AHCIQState *ahci;
ahci = ahci_boot_and_enable();
ahci_test_io_rw_simple(ahci, bufsize, sector,
io_cmds[dma][lba48][IO_READ],
... | false | qemu | debaaa114a8877a939533ba846e64168fb287b7b |
6,853 | static void aio_write_done(void *opaque, int ret)
{
struct aio_ctx *ctx = opaque;
struct timeval t2;
gettimeofday(&t2, NULL);
if (ret < 0) {
printf("aio_write failed: %s\n", strerror(-ret));
goto out;
}
if (ctx->qflag) {
goto out;
}
/* Finall... | false | qemu | 031380d8770d2df6c386e4aeabd412007d3ebd54 |
6,854 | uint64_t helper_fres (uint64_t arg)
{
CPU_DoubleU fone, farg;
float32 f32;
fone.ll = 0x3FF0000000000000ULL; /* 1.0 */
farg.ll = arg;
if (unlikely(float64_is_signaling_nan(farg.d))) {
/* sNaN reciprocal */
farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
} else ... | false | qemu | e33e94f92298c96e0928cefab00ea5bae0a1cd19 |
6,855 | static uint64_t uart_read(void *opaque, target_phys_addr_t addr,
unsigned size)
{
LM32UartState *s = opaque;
uint32_t r = 0;
addr >>= 2;
switch (addr) {
case R_RXTX:
r = s->regs[R_RXTX];
s->regs[R_LSR] &= ~LSR_DR;
uart_update_irq(s);
... | false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c |
6,857 | static int disas_thumb2_insn(CPUARMState *env, DisasContext *s, uint16_t insn_hw1)
{
uint32_t insn, imm, shift, offset;
uint32_t rd, rn, rm, rs;
TCGv_i32 tmp;
TCGv_i32 tmp2;
TCGv_i32 tmp3;
TCGv_i32 addr;
TCGv_i64 tmp64;
int op;
int shiftop;
int conds;
int logic_cc... | false | qemu | 6df99dec9e81838423d723996e96236693fa31fe |
6,858 | static QIOChannelSocket *nbd_establish_connection(SocketAddress *saddr_flat,
Error **errp)
{
SocketAddressLegacy *saddr = socket_address_crumple(saddr_flat);
QIOChannelSocket *sioc;
Error *local_err = NULL;
sioc = qio_channel_socket_new();
q... | false | qemu | bd269ebc82fbaa5fe7ce5bc7c1770ac8acecd884 |
6,859 | void helper_lcall_protected(CPUX86State *env, int new_cs, target_ulong new_eip,
int shift, int next_eip_addend)
{
int new_stack, i;
uint32_t e1, e2, cpl, dpl, rpl, selector, offset, param_count;
uint32_t ss = 0, ss_e1 = 0, ss_e2 = 0, sp, type, ss_dpl, sp_mask;
uint32_t ... | false | qemu | 7848c8d19f8556666df25044bbd5d8b29439c368 |
6,860 | static void tile_codeblocks(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
{
Jpeg2000T1Context t1;
int compno, reslevelno, bandno;
/* Loop on tile components */
for (compno = 0; compno < s->ncomponents; compno++) {
Jpeg2000Component *comp = tile->comp + compno;
Jpeg2000C... | false | FFmpeg | 41bcc3d15204f290400ba02e4e8f87fc07bcc00e |
6,861 | static PCIDevice *do_pci_register_device(PCIDevice *pci_dev, PCIBus *bus,
const char *name, int devfn)
{
PCIDeviceClass *pc = PCI_DEVICE_GET_CLASS(pci_dev);
PCIConfigReadFunc *config_read = pc->config_read;
PCIConfigWriteFunc *config_write = pc->config_write;
... | false | qemu | c31d04b516b183b02336f8cce65a41bd547f6f6b |
6,862 | static int bdrv_inherited_flags(int flags)
{
/* Enable protocol handling, disable format probing for bs->file */
flags |= BDRV_O_PROTOCOL;
/* Our block drivers take care to send flushes and respect unmap policy,
* so we can enable both unconditionally on lower layers. */
flags |= BDRV_O_CAC... | false | qemu | 5669b44de5b3b607a3a4749e0c8c5ddfd723e76b |
6,863 | static inline void gen_movcf_ps(DisasContext *ctx, int fs, int fd,
int cc, int tf)
{
int cond;
TCGv_i32 t0 = tcg_temp_new_i32();
int l1 = gen_new_label();
int l2 = gen_new_label();
if (tf)
cond = TCG_COND_EQ;
else
cond = TCG_COND_NE;
... | false | qemu | 42a268c241183877192c376d03bd9b6d527407c7 |
6,865 | QEMUFile *qemu_fopen(const char *filename, const char *mode)
{
QEMUFile *f;
f = qemu_mallocz(sizeof(QEMUFile));
if (!f)
return NULL;
if (!strcmp(mode, "wb")) {
f->is_writable = 1;
} else if (!strcmp(mode, "rb")) {
f->is_writable = 0;
} else {
goto fai... | false | qemu | 5dafc53f1fb091d242f2179ffcb43bb28af36d1e |
6,868 | void mips_cpu_do_unaligned_access(CPUState *cs, vaddr addr,
int is_write, int is_user, uintptr_t retaddr)
{
MIPSCPU *cpu = MIPS_CPU(cs);
CPUMIPSState *env = &cpu->env;
env->CP0_BadVAddr = addr;
do_raise_exception(env, (is_write == 1) ? EXCP_AdES : EXCP_AdEL, ret... | false | qemu | aea14095ea91f792ee43ee52fe6032cd8cdd7190 |
6,869 | void block_job_cancel(BlockJob *job)
{
job->cancelled = true;
block_job_resume(job);
}
| false | qemu | 751ebd76e654bd1e65da08ecf694325282b4cfcc |
6,870 | PCIBus *pci_pmac_init(qemu_irq *pic,
MemoryRegion *address_space_mem,
MemoryRegion *address_space_io)
{
DeviceState *dev;
SysBusDevice *s;
PCIHostState *h;
UNINState *d;
/* Use values found on a real PowerMac */
/* Uninorth main bus */
... | false | qemu | 8a0e11045d5f50d300e0ab1ba05f4c8217fb5dcb |
6,871 | static inline void downmix_3f_2r_to_dolby(float *samples)
{
int i;
for (i = 0; i < 256; i++) {
samples[i] += (samples[i + 256] - samples[i + 768]);
samples[i + 256] = (samples[i + 512] + samples[i + 1024]);
samples[i + 512] = samples[i + 768] = samples[i + 1024] = 0;
}
}
| false | FFmpeg | 0058584580b87feb47898e60e4b80c7f425882ad |
6,872 | int qemu_paio_ioctl(struct qemu_paiocb *aiocb)
{
return qemu_paio_submit(aiocb, QEMU_PAIO_IOCTL);
}
| false | qemu | 9ef91a677110ec200d7b2904fc4bcae5a77329ad |
6,873 | int rtsp_next_attr_and_value(const char **p, char *attr, int attr_size, char *value, int value_size)
{
skip_spaces(p);
if(**p) {
get_word_sep(attr, attr_size, "=", p);
if (**p == '=')
(*p)++;
get_word_sep(value, value_size, ";", p);
if (**p == ';')
... | false | FFmpeg | c89658008705d949c319df3fa6f400c481ad73e1 |
6,874 | int av_opencl_init(AVDictionary *options, AVOpenCLExternalEnv *ext_opencl_env)
{
int ret = 0;
AVDictionaryEntry *opt_build_entry;
AVDictionaryEntry *opt_platform_entry;
AVDictionaryEntry *opt_device_entry;
LOCK_OPENCL
if (!gpu_env.init_count) {
opt_platform_entry = av_dict_get(op... | false | FFmpeg | 57d77b3963ce1023eaf5ada8cba58b9379405cc8 |
6,875 | static CodeBook unpack_codebook(GetBitContext* gb, unsigned depth,
unsigned size)
{
unsigned i, j;
CodeBook cb = { 0 };
if (!can_safely_read(gb, (uint64_t)size * 34))
return cb;
if (size >= INT_MAX / sizeof(MacroBlock))
return cb;
cb.bloc... | false | FFmpeg | e494f44c051d7dccc038a603ab22532b87dd1705 |
6,876 | static void hybrid4_8_12_cx(float (*in)[2], float (*out)[32][2], const float (*filter)[7][2], int N, int len)
{
int i, j, ssb;
for (i = 0; i < len; i++, in++) {
for (ssb = 0; ssb < N; ssb++) {
float sum_re = filter[ssb][6][0] * in[6][0], sum_im = filter[ssb][6][0] * in[6][1];
... | false | FFmpeg | bf1945af301aff54c33352e75f17aec6cb5269d7 |
6,877 | static int add_metadata(const uint8_t **buf, int count, int type,
const char *name, const char *sep, TiffContext *s)
{
switch(type) {
case TIFF_DOUBLE: return add_doubles_metadata(buf, count, name, sep, s);
case TIFF_SHORT : return add_shorts_metadata(buf, count, name, sep, s);
... | false | FFmpeg | 1ec83d9a9e472f485897ac92bad9631d551a8c5b |
6,878 | static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
{
OptionsContext *o = optctx;
char buf[128];
int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
struct tm time = *gmtime((time_t*)&recording_timestamp);
strftime(buf, sizeof(buf), "creation_time... | false | FFmpeg | c0002ddb019d7f2f22da301b2855f86d697d37bd |
6,880 | static void tcp_chr_tls_init(CharDriverState *chr)
{
TCPCharDriver *s = chr->opaque;
QIOChannelTLS *tioc;
Error *err = NULL;
if (s->is_listen) {
tioc = qio_channel_tls_new_server(
s->ioc, s->tls_creds,
NULL, /* XXX Use an ACL */
&err);
} else {... | true | qemu | 660a2d83e026496db6b3eaec2256a2cdd6c74de8 |
6,881 | rdt_free_extradata (PayloadContext *rdt)
{
ff_rm_free_rmstream(rdt->rmst[0]);
if (rdt->rmctx)
av_close_input_stream(rdt->rmctx);
av_freep(&rdt->mlti_data);
av_free(rdt);
} | true | FFmpeg | c49a3ec30aaa8042335656982054f02847c03aae |
6,882 | static int h263_decode_gob_header(MpegEncContext *s)
{
unsigned int val, gob_number;
int left;
/* Check for GOB Start Code */
val = show_bits(&s->gb, 16);
if(val)
return -1;
/* We have a GBSC probably with GSTUFF */
skip_bits(&s->gb, 16); /* Drop the zeros */
le... | true | FFmpeg | 2baf36caed98cfdc7f6a2086fbf26f1a172f16cf |
6,883 | static int mov_read_wide(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
{
int err;
uint32_t type;
#ifdef DEBUG
print_atom("wide", atom);
debug_indent++;
#endif
if (atom.size < 8)
return 0; /* continue */
if (get_be32(pb) != 0) { /* 0 sized mdat atom... use the 'wide' atom... | true | FFmpeg | fd6e513ee1dc13174256de8adaeeb2c2691eee95 |
6,884 | static void net_socket_send(void *opaque)
{
NetSocketState *s = opaque;
int l, size, err;
uint8_t buf1[4096];
const uint8_t *buf;
size = recv(s->fd, buf1, sizeof(buf1), 0);
if (size < 0) {
err = socket_error();
if (err != EWOULDBLOCK)
goto eoc;
} else... | true | qemu | abcd2baab187cc3b1fcce13b697da5874a123e39 |
6,885 | static void stellaris_enet_write(void *opaque, hwaddr offset,
uint64_t value, unsigned size)
{
stellaris_enet_state *s = (stellaris_enet_state *)opaque;
switch (offset) {
case 0x00: /* IACK */
s->ris &= ~value;
DPRINTF("IRQ ack %02x/%02x\n", value, s... | true | qemu | 5c10495ab1546d5d12b51a97817051e9ec98d0f6 |
6,887 | void *av_malloc(unsigned int size)
{
void *ptr;
#if defined (HAVE_MEMALIGN)
ptr = memalign(16,size);
/* Why 64?
Indeed, we should align it:
on 4 for 386
on 16 for 486
on 32 for 586, PPro - k6-III
on 64 for K7 (maybe for P3 too).
Because L1 and L2 caches ... | false | FFmpeg | da9b170c6f06184a5114dc66afb8385cd0ffff83 |
6,888 | static int posix_aio_process_queue(void *opaque)
{
PosixAioState *s = opaque;
struct qemu_paiocb *acb, **pacb;
int ret;
int result = 0;
for(;;) {
pacb = &s->first_aio;
for(;;) {
acb = *pacb;
if (!acb)
return result;
... | true | qemu | adfe92f6d18c0e0a3694e19abb58eb55fd0c5993 |
6,889 | static int protocol_client_auth(VncState *vs, uint8_t *data, size_t len)
{
/* We only advertise 1 auth scheme at a time, so client
* must pick the one we sent. Verify this */
if (data[0] != vs->auth) { /* Reject auth */
VNC_DEBUG("Reject auth %d because it didn't match advertized\n", (int)data[... | true | qemu | 7364dbdabb7824d5bde1e341bb6d928282f01c83 |
6,890 | static int ehci_process_itd(EHCIState *ehci,
EHCIitd *itd,
uint32_t addr)
{
USBDevice *dev;
USBEndpoint *ep;
uint32_t i, len, pid, dir, devaddr, endp;
uint32_t pg, off, ptr1, ptr2, max, mult;
ehci->periodic_sched_active = PERIODIC_ACT... | true | qemu | b16c129daf0fed91febbb88de23dae8271c8898a |
6,892 | void *g_try_malloc0(size_t n_bytes)
{
__coverity_negative_sink__(n_bytes);
return calloc(1, n_bytes == 0 ? 1 : n_bytes);
}
| true | qemu | 9d7a4c6690ef9962a3b20034f65008f1ea15c1d6 |
6,893 | void gdb_register_coprocessor(CPUState * env,
gdb_reg_cb get_reg, gdb_reg_cb set_reg,
int num_regs, const char *xml, int g_pos)
{
GDBRegisterState *s;
GDBRegisterState **p;
static int last_reg = NUM_CORE_REGS;
s = (GDBRegisterState *)g_m... | true | qemu | 9643c25f8d67646857159d6fc021b07e7a659192 |
6,894 | static int check_refcounts_l1(BlockDriverState *bs,
uint16_t *refcount_table,
int refcount_table_size,
int64_t l1_table_offset, int l1_size,
int check_copied)
{
BDRVQcowState *s = bs->opaque... | true | qemu | 9ac228e02cf16202547e7025ef300369e0db7781 |
6,895 | static int alloc_refcount_block(BlockDriverState *bs,
int64_t cluster_index, void **refcount_block)
{
BDRVQcow2State *s = bs->opaque;
unsigned int refcount_table_index;
int ret;
BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC);
/* Find the refcount block for t... | true | qemu | 95334230637cef9fbd199bb79a56271ec73d4732 |
6,896 | void ppc6xx_irq_init (CPUState *env)
{
env->irq_inputs = (void **)qemu_allocate_irqs(&ppc6xx_set_irq, env, 6);
}
| true | qemu | 7b62a955047934bab158e84ecb63cb432c193ace |
6,897 | static void coroutine_fn v9fs_create(void *opaque)
{
int32_t fid;
int err = 0;
size_t offset = 7;
V9fsFidState *fidp;
V9fsQID qid;
int32_t perm;
int8_t mode;
V9fsPath path;
struct stat stbuf;
V9fsString name;
V9fsString extension;
int iounit;
V9fsPDU *pd... | true | qemu | d63fb193e71644a073b77ff5ac6f1216f2f6cf6e |
6,898 | static int copy_cell(Indeo3DecodeContext *ctx, Plane *plane, Cell *cell)
{
int h, w, mv_x, mv_y, offset, offset_dst;
uint8_t *src, *dst;
/* setup output and reference pointers */
offset_dst = (cell->ypos << 2) * plane->pitch + (cell->xpos << 2);
dst = plane->pixels[ctx->buf_sel]... | true | FFmpeg | 95220be1faac628d849a004644c0d102df0aa98b |
6,899 | static int serial_can_receive(SerialState *s)
{
return !(s->lsr & UART_LSR_DR);
}
| true | qemu | 81174dae3f9189519cd60c7b79e91c291b021bbe |
6,900 | static void mov_parse_stsd_subtitle(MOVContext *c, AVIOContext *pb,
AVStream *st, MOVStreamContext *sc,
int size)
{
// ttxt stsd contains display flags, justification, background
// color, fonts, and default styles, so fake an atom to ... | true | FFmpeg | be9ce6e10a8d53b8bc346c9337d75a5a30631a2a |
6,901 | static void virgl_cmd_get_capset_info(VirtIOGPU *g,
struct virtio_gpu_ctrl_command *cmd)
{
struct virtio_gpu_get_capset_info info;
struct virtio_gpu_resp_capset_info resp;
VIRTIO_GPU_FILL_CMD(info);
if (info.capset_index == 0) {
resp.capset_id = ... | true | qemu | 42a8dadc74f8982fc269e54e3c5627b54d9f83d8 |
6,902 | static int virtio_rng_pci_init(VirtIOPCIProxy *vpci_dev)
{
VirtIORngPCI *vrng = VIRTIO_RNG_PCI(vpci_dev);
DeviceState *vdev = DEVICE(&vrng->vdev);
qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
if (qdev_init(vdev) < 0) {
return -1;
}
object_property_set_link(OBJECT(vrng),
... | true | qemu | 5b456438f5bb395ed6b1eec95e18ce7a7a884a0a |
6,903 | static int usb_linux_update_endp_table(USBHostDevice *s)
{
uint8_t *descriptors;
uint8_t devep, type, configuration, alt_interface;
struct usb_ctrltransfer ct;
int interface, ret, length, i;
ct.bRequestType = USB_DIR_IN;
ct.bRequest = USB_REQ_GET_CONFIGURATION;
ct.wValue = 0;
... | true | qemu | ddbda4323e2bdc7cb3925b0f4080f9eb836a09e8 |
6,904 | AVStream *add_av_stream1(FFStream *stream, AVCodecContext *codec)
{
AVStream *fst;
fst = av_mallocz(sizeof(AVStream));
if (!fst)
return NULL;
fst->priv_data = av_mallocz(sizeof(FeedData));
memcpy(&fst->codec, codec, sizeof(AVCodecContext));
stream->streams[stream->nb_streams++... | true | FFmpeg | a4d70941cd4a82f7db9fbaa2148d60ce550e7611 |
6,905 | static av_cold int ljpeg_encode_init(AVCodecContext *avctx)
{
LJpegEncContext *s = avctx->priv_data;
if ((avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
avctx->color_range == AVCOL_RANGE_MPEG) &&
... | true | FFmpeg | bd12aa2bc597f08409bede6d4c710eddf4d7c142 |
6,906 | void net_host_device_remove(Monitor *mon, int vlan_id, const char *device)
{
VLANState *vlan;
VLANClientState *vc;
vlan = qemu_find_vlan(vlan_id);
if (!vlan) {
monitor_printf(mon, "can't find vlan %d\n", vlan_id);
return;
}
for(vc = vlan->first_client; vc != NULL; vc ... | true | qemu | 9036de1a8ad6c565a4e5d8cd124ad8dd05e7d4d4 |
6,907 | static inline PageDesc *page_find_alloc(target_ulong index)
{
PageDesc **lp, *p;
#if TARGET_LONG_BITS > 32
/* Host memory outside guest VM. For 32-bit targets we have already
excluded high addresses. */
if (index > ((target_ulong)L2_SIZE * L1_SIZE))
return NULL;
#endif
lp = &... | true | qemu | 434929bf11f0573d953c24287badbc2431a042ef |
6,908 | static int asf_write_trailer(AVFormatContext *s)
{
ASFContext *asf = s->priv_data;
int64_t file_size, data_size;
/* flush the current packet */
if (asf->pb.buf_ptr > asf->pb.buffer)
flush_packet(s);
/* write index */
data_size = avio_tell(s->pb);
if ((!asf->is_streamed) ... | false | FFmpeg | 83548fe894cdb455cc127f754d09905b6d23c173 |
6,909 | static void dvbsub_parse_display_definition_segment(AVCodecContext *avctx,
const uint8_t *buf,
int buf_size)
{
DVBSubContext *ctx = avctx->priv_data;
DVBSubDisplayDefinition *display_def = ctx->display_d... | false | FFmpeg | 607ad990d31e6be52980970e5ce8cd25ab3de812 |
6,910 | static int synchronize_audio(VideoState *is, int nb_samples)
{
int wanted_nb_samples = nb_samples;
/* if not master, then we try to remove or add samples to correct the clock */
if (get_master_sync_type(is) != AV_SYNC_AUDIO_MASTER) {
double diff, avg_diff;
int min_nb_samples, max_nb_... | false | FFmpeg | 26c208cf0ff59efd7786528884a64d35fc42e9bf |
6,911 | int ff_alloc_packet(AVPacket *avpkt, int size)
{
if (size > INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE)
return AVERROR(EINVAL);
if (avpkt->data) {
void *destruct = avpkt->destruct;
if (avpkt->size < size)
return AVERROR(EINVAL);
av_init_packet(avpkt);
... | false | FFmpeg | 00663de3b752fc3bdd47d4516ad2fcc720722782 |
6,912 | static int ast_write_trailer(AVFormatContext *s)
{
AVIOContext *pb = s->pb;
ASTMuxContext *ast = s->priv_data;
AVCodecContext *enc = s->streams[0]->codec;
int64_t file_size = avio_tell(pb);
int64_t samples = (file_size - 64 - (32 * enc->frame_number)) / enc->block_align; /* PCM_S16BE_PLANAR */... | false | FFmpeg | 47550e62bf717ed626b652bd3797fcae0ca8c335 |
6,913 | int ff_h264_field_end(H264Context *h, H264SliceContext *sl, int in_setup)
{
AVCodecContext *const avctx = h->avctx;
int err = 0;
h->mb_y = 0;
if (!in_setup && !h->droppable)
ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
h->picture_structure ==... | false | FFmpeg | c8dcff0cdb17d0aa03ac729eba12d1a20f1f59c8 |
6,914 | static int audio_read_packet(AVFormatContext *s1, AVPacket *pkt)
{
AlsaData *s = s1->priv_data;
AVStream *st = s1->streams[0];
int res;
snd_htimestamp_t timestamp;
snd_pcm_uframes_t ts_delay;
if (av_new_packet(pkt, s->period_size) < 0) {
return AVERROR(EIO);
}
whil... | false | FFmpeg | 089fac77a6bf9199a5ec161e9c27850f0a680541 |
6,915 | static void RENAME(uyvytoyuv422)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst, const uint8_t *src,
long width, long height,
long lumStride, long chromStride, long srcStride)
{
long y;
const long chromWidth= -((-width)>>1);
fo... | false | FFmpeg | d1adad3cca407f493c3637e20ecd4f7124e69212 |
6,916 | static int mpc8_decode_init(AVCodecContext * avctx)
{
int i;
MPCContext *c = avctx->priv_data;
GetBitContext gb;
static int vlc_inited = 0;
if(avctx->extradata_size < 2){
av_log(avctx, AV_LOG_ERROR, "Too small extradata size (%i)!\n", avctx->extradata_size);
return -1;
... | false | FFmpeg | 5e53486545726987ab4482321d4dcf7e23e7652f |
6,918 | static int raw_pwrite_aligned(BlockDriverState *bs, int64_t offset,
const uint8_t *buf, int count)
{
BDRVRawState *s = bs->opaque;
int ret;
ret = fd_open(bs);
if (ret < 0)
return -errno;
ret = pwrite(s->fd, buf, count, offset);
if (ret == count)
... | false | qemu | 65d21bc73bda6515fd9b4ff5b2e90454f7a0b419 |
6,920 | void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap)
{
BdrvDirtyBitmap *bm, *next;
QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) {
if (bm == bitmap) {
assert(!bdrv_dirty_bitmap_frozen(bm));
QLIST_REMOVE(bitmap, list);
hbitmap_f... | false | qemu | c5acdc9ab4e6aa9b05e6242114479333b15d496b |
6,922 | void memory_region_init_ram(MemoryRegion *mr,
Object *owner,
const char *name,
uint64_t size)
{
memory_region_init(mr, owner, name, size);
mr->ram = true;
mr->terminates = true;
mr->destructor = memory_region_des... | false | qemu | e1c57ab86f3c4ea6532b51cfecf32770b45f5e7a |
6,923 | int ff_h264_decode_slice_header(H264Context *h, H264Context *h0)
{
unsigned int first_mb_in_slice;
unsigned int pps_id;
int ret;
unsigned int slice_type, tmp, i, j;
int last_pic_structure, last_pic_droppable;
int must_reinit;
int needs_reinit = 0;
int field_pic_flag, bottom_fiel... | false | FFmpeg | d381109ce8acd84fc16d3dfc4f8f688462d45366 |
6,924 | static void virtio_scsi_request_cancelled(SCSIRequest *r)
{
VirtIOSCSIReq *req = r->hba_private;
if (!req) {
return;
}
if (req->dev->resetting) {
req->resp.cmd->response = VIRTIO_SCSI_S_RESET;
} else {
req->resp.cmd->response = VIRTIO_SCSI_S_ABORTED;
}
vi... | false | qemu | 3eff1f46f08a360a4ae9f834ce9fef4c45bf6f0f |
6,925 | void HELPER(access_check_cp_reg)(CPUARMState *env, void *rip, uint32_t syndrome)
{
const ARMCPRegInfo *ri = rip;
int target_el;
if (arm_feature(env, ARM_FEATURE_XSCALE) && ri->cp < 14
&& extract32(env->cp15.c15_cpar, ri->cp, 1) == 0) {
raise_exception(env, EXCP_UDEF, syndrome, except... | false | qemu | 3fc827d591679f3e262b9d1f8b34528eabfca8c0 |
6,926 | static void notify_event_cb(void *opaque)
{
/* No need to do anything; this bottom half is only used to
* kick the kernel out of ppoll/poll/WaitForMultipleObjects.
*/
}
| false | qemu | c2b38b277a7882a592f4f2ec955084b2b756daaa |
6,928 | static int m25p80_init(SSISlave *ss)
{
DriveInfo *dinfo;
Flash *s = M25P80(ss);
M25P80Class *mc = M25P80_GET_CLASS(s);
s->pi = mc->pi;
s->size = s->pi->sector_size * s->pi->n_sectors;
s->dirty_page = -1;
s->storage = qemu_blockalign(s->bdrv, s->size);
dinfo = drive_get_nex... | false | qemu | 4be746345f13e99e468c60acbd3a355e8183e3ce |
6,929 | static void sdl_mouse_warp(int x, int y, int on)
{
if (on) {
if (!guest_cursor)
sdl_show_cursor();
if (gui_grab || kbd_mouse_is_absolute() || absolute_enabled) {
SDL_SetCursor(guest_sprite);
SDL_WarpMouse(x, y);
}
} else if (gui_grab)
... | false | qemu | 08a2d4c4ffde60e48819449f461274c43ad6e2d3 |
6,930 | static int qcow2_cache_do_get(BlockDriverState *bs, Qcow2Cache *c,
uint64_t offset, void **table, bool read_from_disk)
{
BDRVQcowState *s = bs->opaque;
int i;
int ret;
int lookup_index;
uint64_t min_lru_counter = UINT64_MAX;
int min_lru_index = -1;
trace_qcow2_cache_get(qemu_c... | false | qemu | 1bd84ee717bf146c19281cce48a36a2f4d71748d |
6,932 | int net_init_socket(QemuOpts *opts,
Monitor *mon,
const char *name,
VLANState *vlan)
{
if (qemu_opt_get(opts, "fd")) {
int fd;
if (qemu_opt_get(opts, "listen") ||
qemu_opt_get(opts, "connect") ||
qemu_opt_... | false | qemu | 62112d181ca33fea976100c4335dfc3e2f727e6c |
6,934 | int ff_init_filters(SwsContext * c)
{
int i;
int index;
int num_ydesc;
int num_cdesc;
int num_vdesc = isPlanarYUV(c->dstFormat) && !isGray(c->dstFormat) ? 2 : 1;
int need_lum_conv = c->lumToYV12 || c->readLumPlanar || c->alpToYV12 || c->readAlpPlanar;
int need_chr_conv = c->chrToYV12... | false | FFmpeg | f67aff3ad7168b0721e7e5ba05858d885966534a |
6,936 | void commit_start(const char *job_id, BlockDriverState *bs,
BlockDriverState *base, BlockDriverState *top, int64_t speed,
BlockdevOnError on_error, const char *backing_file_str,
Error **errp)
{
CommitBlockJob *s;
BlockReopenQueue *reopen_queue = NULL;
... | false | qemu | 8dfba2797761d8a43744e4e6571c8175e448a478 |
6,937 | int load_elf(const char *filename, int64_t virt_to_phys_addend,
uint64_t *pentry)
{
int fd, data_order, must_swab, ret;
uint8_t e_ident[EI_NIDENT];
fd = open(filename, O_RDONLY | O_BINARY);
if (fd < 0) {
perror(filename);
return -1;
}
if (read(fd, e_ident... | false | qemu | 9042c0e20de166542b603621fd30dc8be95dfd4d |
6,938 | qemu_inject_x86_mce(CPUState *cenv, int bank, uint64_t status,
uint64_t mcg_status, uint64_t addr, uint64_t misc)
{
uint64_t mcg_cap = cenv->mcg_cap;
uint64_t *banks = cenv->mce_banks;
/*
* if MSR_MCG_CTL is not all 1s, the uncorrected error
* reporting is disabled
... | false | qemu | 316378e4d0214b45cfeaa01609aca4dabb18d78b |
6,939 | static USBDevice *usb_msd_init(const char *filename)
{
static int nr=0;
char id[8];
QemuOpts *opts;
DriveInfo *dinfo;
USBDevice *dev;
int fatal_error;
const char *p1;
char fmt[32];
/* parse -usbdevice disk: syntax into drive opts */
snprintf(id, sizeof(id), "usb%d", ... | false | qemu | f8b6cc0070aab8b75bd082582c829be1353f395f |
6,940 | static inline void gen_evmergelo(DisasContext *ctx)
{
if (unlikely(!ctx->spe_enabled)) {
gen_exception(ctx, POWERPC_EXCP_APU);
return;
}
#if defined(TARGET_PPC64)
TCGv t0 = tcg_temp_new();
TCGv t1 = tcg_temp_new();
tcg_gen_ext32u_tl(t0, cpu_gpr[rB(ctx->opcode)]);
tcg_ge... | false | qemu | 27a69bb088bee6d4efea254659422fb9c751b3c7 |
6,942 | static int64_t cache_seek(URLContext *h, int64_t pos, int whence)
{
Context *c= h->priv_data;
if (whence == AVSEEK_SIZE) {
pos= ffurl_seek(c->inner, pos, whence);
if(pos <= 0){
pos= ffurl_seek(c->inner, -1, SEEK_END);
ffurl_seek(c->inner, c->end, SEEK_SET);
... | false | FFmpeg | eb19d89d8eb51f20299d59558d69d0f057583e7c |
6,943 | static int sonic_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
const AVFrame *frame, int *got_packet_ptr)
{
SonicContext *s = avctx->priv_data;
RangeCoder c;
int i, j, ch, quant = 0, x = 0;
int ret;
const short *samples = (const int16_t*)frame->data[0];
... | false | FFmpeg | c131a9fead5bf63215b6e1172b3c5c183cf90b85 |
6,944 | int tpm_register_driver(const TPMDriverOps *tdo)
{
int i;
for (i = 0; i < TPM_MAX_DRIVERS; i++) {
if (!be_drivers[i]) {
be_drivers[i] = tdo;
return 0;
}
}
error_report("Could not register TPM driver");
return 1;
}
| true | qemu | a9a72aeefbd3ef8bcbbeeccaf174ee10db2978ac |
6,945 | static void xilinx_axidma_init(Object *obj)
{
XilinxAXIDMA *s = XILINX_AXI_DMA(obj);
SysBusDevice *sbd = SYS_BUS_DEVICE(obj);
object_property_add_link(obj, "axistream-connected", TYPE_STREAM_SLAVE,
(Object **)&s->tx_data_dev, &error_abort);
object_property_add_link(o... | true | qemu | 9561fda8d90e176bef598ba87c42a1bd6ad03ef7 |
6,947 | static int count_contiguous_free_clusters(int nb_clusters, uint64_t *l2_table)
{
int i;
for (i = 0; i < nb_clusters; i++) {
int type = qcow2_get_cluster_type(be64_to_cpu(l2_table[i]));
if (type != QCOW2_CLUSTER_UNALLOCATED) {
break;
}
}
return i;
}
| true | qemu | a99dfb45f26bface6830ee5465e57bcdbc53c6c8 |
6,948 | void ide_init_ioport(IDEBus *bus, ISADevice *dev, int iobase, int iobase2)
{
/* ??? Assume only ISA and PCI configurations, and that the PCI-ISA
bridge has been setup properly to always register with ISA. */
isa_register_portio_list(dev, iobase, ide_portio_list, bus, "ide");
if (iobase2) {
... | true | qemu | e305a16510afa74eec20390479e349402e55ef4c |
6,949 | static int read_huffman_tables(HYuvContext *s, uint8_t *src, int length){
GetBitContext gb;
int i;
init_get_bits(&gb, src, length*8);
for(i=0; i<3; i++){
read_len_table(s->len[i], &gb);
if(generate_bits_table(s->bits[i], s->len[i])<0){
return -1;
}
#if ... | true | FFmpeg | e30004fa733ec64b6ff90678098c1f1132d4d603 |
6,950 | static int parse_bit(DeviceState *dev, Property *prop, const char *str)
{
if (!strcasecmp(str, "on"))
bit_prop_set(dev, prop, true);
else if (!strcasecmp(str, "off"))
bit_prop_set(dev, prop, false);
else
return -EINVAL;
return 0;
}
| true | qemu | 5cb9b56acfc0b50acf7ccd2d044ab4991c47fdde |
6,952 | int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
{
int prefix_val = 0;
int suffix_val = 0;
int inc = 0;
while (prefix_val < 5 && GET_CABAC(elem_offset[CU_QP_DELTA] + inc)) {
prefix_val++;
inc = 1;
}
if (prefix_val >= 5) {
int k = 0;
while (k < CABAC_MAX_BI... | true | FFmpeg | 0ee143558d55b590774dba69cff5a16eda089a4d |
6,954 | static inline void gdb_continue(GDBState *s)
{
#ifdef CONFIG_USER_ONLY
s->running_state = 1;
#else
vm_start();
#endif
}
| true | qemu | 87f25c12bfeaaa0c41fb857713bbc7e8a9b757dc |
6,955 | av_cold int ff_nvenc_encode_close(AVCodecContext *avctx)
{
NVENCContext *ctx = avctx->priv_data;
NV_ENCODE_API_FUNCTION_LIST *nv = &ctx->nvel.nvenc_funcs;
int i;
av_fifo_free(ctx->timestamps);
av_fifo_free(ctx->pending);
av_fifo_free(ctx->ready);
if (ctx->in) {
for (i =... | true | FFmpeg | aac7d6b284c3976eb0c48d61f342f008fb6e4103 |
6,957 | static void trigger_console_data(void *opaque, int n, int level)
{
sclp_service_interrupt(0);
}
| true | qemu | 4f3ed190a673c0020c3ccebb4882ae4675cb5f4d |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.