project stringclasses 2
values | commit_id stringlengths 40 40 | target int64 0 1 | func stringlengths 26 142k | idx int64 0 27.3k |
|---|---|---|---|---|
FFmpeg | 27c7ca9c12bb42d5c44d46f24cd970469d0ef55a | 0 | void ff_read_frame_flush(AVFormatContext *s)
{
AVStream *st;
int i, j;
flush_packet_queue(s);
s->cur_st = NULL;
/* for each stream, reset read state */
for(i = 0; i < s->nb_streams; i++) {
st = s->streams[i];
if (st->parser) {
av_parser_close(st->par... | 16,573 |
FFmpeg | 4b1f5e5090abed6c618c8ba380cd7d28d140f867 | 0 | void av_register_input_format(AVInputFormat *format)
{
AVInputFormat **p = &first_iformat;
while (*p != NULL)
p = &(*p)->next;
*p = format;
format->next = NULL;
}
| 16,574 |
FFmpeg | 0c0aef1caf0cb5dd3b294f9fff923175036bd985 | 0 | static void set_http_options(AVFormatContext *s, AVDictionary **options, HLSContext *c)
{
const char *proto = avio_find_protocol_name(s->filename);
int http_base_proto = !av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https");
if (c->method) {
av_dict_set(options, "method", c->method,... | 16,575 |
FFmpeg | 6a63ff19b6a7fe3bc32c7fb4a62fca8f65786432 | 0 | static int mov_read_ctts(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
{
AVStream *st = c->fc->streams[c->fc->nb_streams-1];
MOVStreamContext *sc = st->priv_data;
unsigned int i, entries;
get_byte(pb); /* version */
get_be24(pb); /* flags */
entries = get_be32(pb);
dprintf(c->f... | 16,576 |
qemu | 58aebb946acff82c62383f350cab593e55cc13dc | 0 | int cpu_cris_handle_mmu_fault (CPUState *env, target_ulong address, int rw,
int mmu_idx, int is_softmmu)
{
struct cris_mmu_result res;
int prot, miss;
int r = -1;
target_ulong phy;
D(printf ("%s addr=%x pc=%x rw=%x\n", __func__, address, env->pc, rw));
miss = cris_mmu_tran... | 16,579 |
FFmpeg | d8edf1b515ae9fbcea2103305241d130c16e1003 | 0 | static av_always_inline void rv40_adaptive_loop_filter(uint8_t *src, const int step,
const int stride, const int dmode,
const int lim_q1, const int lim_p1,
const int alpha,
... | 16,580 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | void framebuffer_update_display(
DisplayState *ds,
MemoryRegion *address_space,
target_phys_addr_t base,
int cols, /* Width in pixels. */
int rows, /* Height in pixels. */
int src_width, /* Length of source line, in bytes. */
int dest_row_pitch, /* Bytes between adjacent horizontal... | 16,581 |
qemu | 37ad223c515da2fe9f1c679768cb5ccaa42e57e1 | 0 | build_mcfg(GArray *table_data, GArray *linker, VirtGuestInfo *guest_info)
{
AcpiTableMcfg *mcfg;
const MemMapEntry *memmap = guest_info->memmap;
int len = sizeof(*mcfg) + sizeof(mcfg->allocation[0]);
mcfg = acpi_data_push(table_data, len);
mcfg->allocation[0].address = cpu_to_le64(memmap[VIR... | 16,583 |
qemu | 84a12e6648444f517055138a7d7f25a22d7e1029 | 0 | static void bdrv_raw_init(void)
{
bdrv_register(&bdrv_raw);
bdrv_register(&bdrv_host_device);
}
| 16,586 |
qemu | 677ef6230b603571ae05125db469f7b4c8912a77 | 0 | void helper_lock(void)
{
spin_lock(&global_cpu_lock);
}
| 16,587 |
qemu | 904d6f588063fb5ad2b61998acdf1e73fb465067 | 0 | static void handle_input(VirtIODevice *vdev, VirtQueue *vq)
{
VirtIORNG *vrng = DO_UPCAST(VirtIORNG, vdev, vdev);
size_t size;
size = pop_an_elem(vrng);
if (size) {
rng_backend_request_entropy(vrng->rng, size, chr_read, vrng);
}
}
| 16,588 |
qemu | 056dfcb695cde3c62b7dc1d5ed6d2e38b3a73e29 | 0 | bool vfio_blacklist_opt_rom(VFIOPCIDevice *vdev)
{
PCIDevice *pdev = &vdev->pdev;
uint16_t vendor_id, device_id;
int count = 0;
vendor_id = pci_get_word(pdev->config + PCI_VENDOR_ID);
device_id = pci_get_word(pdev->config + PCI_DEVICE_ID);
while (count < ARRAY_SIZE(romblacklist)) {
... | 16,589 |
qemu | fb23162885f7fd8cf7334bed22c25ac32c7d8b9d | 0 | static PCIDevice *do_pci_register_device(PCIDevice *pci_dev, PCIBus *bus,
const char *name, int devfn,
PCIConfigReadFunc *config_read,
PCIConfigWriteFunc *config_write)
{
if (devfn < 0) {
... | 16,590 |
FFmpeg | 00dd9a6d6a5c3cc209082023595354a81aff9bb9 | 0 | static int pcm_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
const uint8_t *src = avpkt->data;
int buf_size = avpkt->size;
PCMDecode *s = avctx->priv_data;
int sample_size, c, n, ret, samples_per_block;
uint8_t *... | 16,591 |
qemu | 922453bca6a927bb527068ae8679d587cfa45dbc | 0 | void bmdma_cmd_writeb(BMDMAState *bm, uint32_t val)
{
#ifdef DEBUG_IDE
printf("%s: 0x%08x\n", __func__, val);
#endif
/* Ignore writes to SSBM if it keeps the old value */
if ((val & BM_CMD_START) != (bm->cmd & BM_CMD_START)) {
if (!(val & BM_CMD_START)) {
/*
* We ... | 16,592 |
qemu | e9a0152ba182c5ce9929ee60f83a37b61a1d5195 | 0 | static void virtio_9p_get_config(VirtIODevice *vdev, uint8_t *config)
{
struct virtio_9p_config *cfg;
V9fsState *s = to_virtio_9p(vdev);
cfg = g_malloc0(sizeof(struct virtio_9p_config) +
s->tag_len);
stw_raw(&cfg->tag_len, s->tag_len);
memcpy(cfg->tag, s->tag, s->tag... | 16,593 |
qemu | ed6273e26fdfb94a282dbbf1234a75422c6b4c4b | 0 | static NetSocketState *net_socket_fd_init_dgram(NetClientState *peer,
const char *model,
const char *name,
int fd, int is_connected)
{
struct sockaddr_in saddr;
i... | 16,594 |
qemu | c9fbb99d41b05acf0d7b93deb2fcdbf9047c238e | 0 | static int qcow2_create2(const char *filename, int64_t total_size,
const char *backing_file, const char *backing_format,
int flags, size_t cluster_size, int prealloc,
QEMUOptionParameter *options, int version,
Error ... | 16,595 |
qemu | bec1631100323fac0900aea71043d5c4e22fc2fa | 0 | static void tci_out_label(TCGContext *s, TCGArg arg)
{
TCGLabel *label = &s->labels[arg];
if (label->has_value) {
tcg_out_i(s, label->u.value);
assert(label->u.value);
} else {
tcg_out_reloc(s, s->code_ptr, sizeof(tcg_target_ulong), arg, 0);
s->code_ptr += sizeof(tcg_... | 16,598 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | uint32_t lduw_le_phys(target_phys_addr_t addr)
{
return lduw_phys_internal(addr, DEVICE_LITTLE_ENDIAN);
}
| 16,599 |
qemu | 384acbf46b70edf0d2c1648aa1a92a90bcf7057d | 0 | int get_async_context_id(void)
{
return async_context->id;
}
| 16,600 |
qemu | fd56e0612b6454a282fa6a953fdb09281a98c589 | 0 | static void piix4_pm_realize(PCIDevice *dev, Error **errp)
{
PIIX4PMState *s = PIIX4_PM(dev);
uint8_t *pci_conf;
pci_conf = dev->config;
pci_conf[0x06] = 0x80;
pci_conf[0x07] = 0x02;
pci_conf[0x09] = 0x00;
pci_conf[0x3d] = 0x01; // interrupt pin 1
/* APM */
apm_init(dev... | 16,601 |
qemu | a7812ae412311d7d47f8aa85656faadac9d64b56 | 0 | static always_inline void gen_qemu_ldg (TCGv t0, TCGv t1, int flags)
{
TCGv tmp = tcg_temp_new(TCG_TYPE_I64);
tcg_gen_qemu_ld64(tmp, t1, flags);
tcg_gen_helper_1_1(helper_memory_to_g, t0, tmp);
tcg_temp_free(tmp);
}
| 16,603 |
qemu | ac1970fbe8ad5a70174f462109ac0f6c7bf1bc43 | 0 | static void register_subpage(MemoryRegionSection *section)
{
subpage_t *subpage;
target_phys_addr_t base = section->offset_within_address_space
& TARGET_PAGE_MASK;
MemoryRegionSection *existing = phys_page_find(base >> TARGET_PAGE_BITS);
MemoryRegionSection subsection = {
.offset_... | 16,604 |
qemu | 90e496386fe7fd32c189561f846b7913f95b8cf4 | 0 | static void do_fp_st(DisasContext *s, int srcidx, TCGv_i64 tcg_addr, int size)
{
/* This writes the bottom N bits of a 128 bit wide vector to memory */
TCGv_i64 tmp = tcg_temp_new_i64();
tcg_gen_ld_i64(tmp, cpu_env, fp_reg_offset(srcidx, MO_64));
if (size < 4) {
tcg_gen_qemu_st_i64(tmp, tc... | 16,605 |
qemu | ac1970fbe8ad5a70174f462109ac0f6c7bf1bc43 | 0 | bool cpu_physical_memory_is_io(target_phys_addr_t phys_addr)
{
MemoryRegionSection *section;
section = phys_page_find(phys_addr >> TARGET_PAGE_BITS);
return !(memory_region_is_ram(section->mr) ||
memory_region_is_romd(section->mr));
}
| 16,606 |
qemu | 3dc6f8693694a649a9c83f1e2746565b47683923 | 0 | void qemu_start_warp_timer(void)
{
int64_t clock;
int64_t deadline;
if (!use_icount) {
return;
}
/* Nothing to do if the VM is stopped: QEMU_CLOCK_VIRTUAL timers
* do not fire, so computing the deadline does not make sense.
*/
if (!runstate_is_running()) {
... | 16,607 |
qemu | d368ba4376b2c1c24175c74b3733b8fe64dbe8a6 | 0 | sdhci_writefn(void *opaque, hwaddr off, uint64_t val, unsigned sz)
{
SDHCIState *s = (SDHCIState *)opaque;
SDHCI_GET_CLASS(s)->mem_write(s, off, val, sz);
}
| 16,608 |
qemu | 210b580b106fa798149e28aa13c66b325a43204e | 0 | static void rtas_set_xive(sPAPREnvironment *spapr, uint32_t token,
uint32_t nargs, target_ulong args,
uint32_t nret, target_ulong rets)
{
struct ics_state *ics = spapr->icp->ics;
uint32_t nr, server, priority;
if ((nargs != 3) || (nret != 1)) {
... | 16,609 |
qemu | b3db211f3c80bb996a704d665fe275619f728bd4 | 0 | static void test_validate_fail_list(TestInputVisitorData *data,
const void *unused)
{
UserDefOneList *head = NULL;
Error *err = NULL;
Visitor *v;
v = validate_test_init(data, "[ { 'string': 'string0', 'integer': 42 }, { 'string': 'string1', 'integer': 43 }, {... | 16,610 |
qemu | a6d34a949c3546404d403bda61a5e37431b4a6ad | 0 | static int migrate_fd_cleanup(MigrationState *s)
{
int ret = 0;
qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
if (s->file) {
DPRINTF("closing file\n");
if (qemu_fclose(s->file) != 0) {
ret = -1;
}
s->file = NULL;
} else {
if (s->m... | 16,611 |
qemu | ab33fcda9f96b9195dfb3fcf5bd9bb5383caeaea | 1 | static bool all_cpu_threads_idle(void)
{
CPUState *env;
for (env = first_cpu; env != NULL; env = env->next_cpu) {
if (!cpu_thread_is_idle(env)) {
return false;
}
}
return true;
}
| 16,612 |
qemu | 0d4cc3e715f5794077895345577725539afe81eb | 1 | static int vpc_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
{
BDRVVPCState *s = (BDRVVPCState *)bs->opaque;
VHDFooter *footer = (VHDFooter *) s->footer_buf;
if (cpu_to_be32(footer->type) != VHD_FIXED) {
bdi->cluster_size = s->block_size;
}
bdi->unallocated_blocks_are_zero ... | 16,613 |
FFmpeg | bd8201566d754384105923bb1fb3bb3a5c08cc8b | 1 | static int read_header_openmpt(AVFormatContext *s)
{
AVStream *st;
OpenMPTContext *openmpt = s->priv_data;
int64_t size = avio_size(s->pb);
if (!size)
return AVERROR_INVALIDDATA;
char *buf = av_malloc(size);
int ret;
if (!buf)
return AVERROR(ENOMEM);
size =... | 16,615 |
qemu | d279279e2b5cd40dbcc863fb66a695990f304077 | 1 | void helper_mtc0_hwrena(CPUMIPSState *env, target_ulong arg1)
{
env->CP0_HWREna = arg1 & 0x0000000F;
}
| 16,616 |
qemu | aa2c364b4cf2fae4d9c8acf53ee4436ed533902d | 1 | void qemu_cpu_kick(void *_env)
{
CPUState *env = _env;
qemu_cond_broadcast(env->halt_cond);
qemu_thread_signal(env->thread, SIG_IPI);
}
| 16,617 |
qemu | e829b0bb054ed3389e5b22dad61875e51674e629 | 1 | iscsi_inquiry_cb(struct iscsi_context *iscsi, int status, void *command_data,
void *opaque)
{
struct IscsiTask *itask = opaque;
struct scsi_task *task = command_data;
struct scsi_inquiry_standard *inq;
if (status != 0) {
itask->status = 1;
itask->complete = 1... | 16,618 |
qemu | 29851ee7c8bd3fb8542e21cd0270c73132590350 | 1 | static inline uint8_t mipsdsp_lshift8(uint8_t a, uint8_t s, CPUMIPSState *env)
{
uint8_t sign;
uint8_t discard;
if (s == 0) {
return a;
} else {
sign = (a >> 7) & 0x01;
if (sign != 0) {
discard = (((0x01 << (8 - s)) - 1) << s) |
((a >... | 16,619 |
FFmpeg | 1c495b0bf690995c45f79f4f19500921e14ec78a | 1 | static void dwt_encode97_float(DWTContext *s, float *t)
{
int lev,
w = s->linelen[s->ndeclevels-1][0];
float *line = s->f_linebuf;
line += 5;
for (lev = s->ndeclevels-1; lev >= 0; lev--){
int lh = s->linelen[lev][0],
lv = s->linelen[lev][1],
mh = s->mod... | 16,620 |
qemu | e98ccb3fbba94d0b2165caabf7aeee370d4ce900 | 1 | static void taihu_405ep_init(ram_addr_t ram_size,
const char *boot_device,
const char *kernel_filename,
const char *kernel_cmdline,
const char *initrd_filename,
const cha... | 16,621 |
FFmpeg | 10306e9c5fcc28bd9310a9b38f21540e9e1433e9 | 0 | int ff_jpeg2000_init_component(Jpeg2000Component *comp,
Jpeg2000CodingStyle *codsty,
Jpeg2000QuantStyle *qntsty,
int cbps, int dx, int dy,
AVCodecContext *avctx)
{
uint8_t log2_band_prec... | 16,622 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static void bonito_writel(void *opaque, target_phys_addr_t addr,
uint64_t val, unsigned size)
{
PCIBonitoState *s = opaque;
uint32_t saddr;
int reset = 0;
saddr = (addr - BONITO_REGBASE) >> 2;
DPRINTF("bonito_writel "TARGET_FMT_plx" val %x saddr %x\n", addr, val,... | 16,623 |
FFmpeg | bcaf64b605442e1622d16da89d4ec0e7730b8a8c | 0 | static int aacPlus_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
const AVFrame *frame, int *got_packet)
{
aacPlusAudioContext *s = avctx->priv_data;
int32_t *input_buffer = (int32_t *)frame->data[0];
int ret;
if ((ret = ff_alloc_packet2(avctx, pkt, s->max_out... | 16,625 |
qemu | 77af8a2b95b79699de650965d5228772743efe84 | 0 | static void test_acpi_fadt_table(test_data *data)
{
AcpiFadtDescriptorRev1 *fadt_table = &data->fadt_table;
uint32_t addr;
/* FADT table comes first */
addr = data->rsdt_tables_addr[0];
ACPI_READ_TABLE_HEADER(fadt_table, addr);
ACPI_READ_FIELD(fadt_table->firmware_ctrl, addr);
AC... | 16,626 |
qemu | d9f62dde1303286b24ac8ce88be27e2b9b9c5f46 | 0 | opts_end_list(Visitor *v)
{
OptsVisitor *ov = to_ov(v);
assert(ov->list_mode == LM_STARTED ||
ov->list_mode == LM_IN_PROGRESS ||
ov->list_mode == LM_SIGNED_INTERVAL ||
ov->list_mode == LM_UNSIGNED_INTERVAL);
ov->repeated_opts = NULL;
ov->list_mode = LM_NONE;
}... | 16,627 |
qemu | 74475455442398a64355428b37422d14ccc293cb | 0 | static void rate_start (SpiceRateCtl *rate)
{
memset (rate, 0, sizeof (*rate));
rate->start_ticks = qemu_get_clock (vm_clock);
}
| 16,629 |
qemu | 6482b0ffd12ce83810c10b1a3884a75eba2ade1a | 0 | void cpu_inject_ext(S390CPU *cpu, uint32_t code, uint32_t param,
uint64_t param64)
{
CPUS390XState *env = &cpu->env;
if (env->ext_index == MAX_EXT_QUEUE - 1) {
/* ugh - can't queue anymore. Let's drop. */
return;
}
env->ext_index++;
assert(env->ext_in... | 16,630 |
qemu | a06b1dae4706fccb9394b35e88d1905dabec85e7 | 0 | static void virtio_serial_device_realize(DeviceState *dev, Error **errp)
{
VirtIODevice *vdev = VIRTIO_DEVICE(dev);
VirtIOSerial *vser = VIRTIO_SERIAL(dev);
uint32_t i, max_supported_ports;
if (!vser->serial.max_virtserial_ports) {
error_setg(errp, "Maximum number of serial ports not spe... | 16,631 |
qemu | 09e68369a88d7de0f988972bf28eec1b80cc47f9 | 0 | void object_property_set_qobject(Object *obj, QObject *value,
const char *name, Error **errp)
{
Visitor *v;
/* TODO: Should we reject, rather than ignore, excess input? */
v = qmp_input_visitor_new(value, false);
object_property_set(obj, v, name, errp);
visit_... | 16,632 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static uint32_t pci_apb_ioreadb (void *opaque, target_phys_addr_t addr)
{
uint32_t val;
val = cpu_inb(addr & IOPORTS_MASK);
return val;
}
| 16,634 |
qemu | 4be746345f13e99e468c60acbd3a355e8183e3ce | 0 | static void virtio_blk_device_unrealize(DeviceState *dev, Error **errp)
{
VirtIODevice *vdev = VIRTIO_DEVICE(dev);
VirtIOBlock *s = VIRTIO_BLK(dev);
remove_migration_state_change_notifier(&s->migration_state_notifier);
virtio_blk_data_plane_destroy(s->dataplane);
s->dataplane = NULL;
qe... | 16,635 |
FFmpeg | ce87711df563a9d2d0537a062b86bb91b15ea1a0 | 0 | static int exif_decode_tag(AVCodecContext *avctx, GetByteContext *gbytes, int le,
int depth, AVDictionary **metadata)
{
int ret, cur_pos;
unsigned id, count;
enum TiffTypes type;
if (depth > 2) {
return 0;
}
ff_tread_tag(gbytes, le, &id, &type, &co... | 16,636 |
qemu | 41ecc72ba5932381208e151bf2d2149a0342beff | 0 | static int setup_sigcontext(struct target_sigcontext *sc, CPUAlphaState *env,
abi_ulong frame_addr, target_sigset_t *set)
{
int i, err = 0;
__put_user(on_sig_stack(frame_addr), &sc->sc_onstack);
__put_user(set->sig[0], &sc->sc_mask);
__put_user(env->pc, &sc->sc_pc);
... | 16,637 |
qemu | a4a1c70dc759e5b81627e96564f344ab43ea86eb | 0 | static const char *full_name(QObjectInputVisitor *qiv, const char *name)
{
StackObject *so;
char buf[32];
if (qiv->errname) {
g_string_truncate(qiv->errname, 0);
} else {
qiv->errname = g_string_new("");
}
QSLIST_FOREACH(so , &qiv->stack, node) {
if (qobject... | 16,638 |
qemu | 880e52b8b037d5878c1120a15b45ebf6ac690d31 | 0 | static void tcg_out_tlb_read (TCGContext *s, int r0, int r1, int r2,
int addr_reg, int s_bits, int offset)
{
#ifdef TARGET_LONG_BITS
tcg_out_rld (s, RLDICL, addr_reg, addr_reg, 0, 32);
tcg_out32 (s, (RLWINM
| RA (r0)
| RS (addr_reg)
... | 16,639 |
qemu | e8ede0a8bb5298a6979bcf7ed84ef64a64a4e3fe | 0 | float32 HELPER(ucf64_si2sf)(float32 x, CPUUniCore32State *env)
{
return int32_to_float32(ucf64_stoi(x), &env->ucf64.fp_status);
}
| 16,640 |
qemu | 9d40cd8a68cfc7606f4548cc9e812bab15c6dc28 | 0 | static void v7m_push_stack(ARMCPU *cpu)
{
/* Do the "set up stack frame" part of exception entry,
* similar to pseudocode PushStack().
*/
CPUARMState *env = &cpu->env;
uint32_t xpsr = xpsr_read(env);
/* Align stack pointer if the guest wants that */
if ((env->regs[13] & 4) && (en... | 16,641 |
qemu | fa879d62eb51253d00b6920ce1d1d9d261370a49 | 0 | int bdrv_attach(BlockDriverState *bs, DeviceState *qdev)
{
if (bs->peer) {
return -EBUSY;
}
bs->peer = qdev;
return 0;
}
| 16,642 |
qemu | 7bd427d801e1e3293a634d3c83beadaa90ffb911 | 0 | static void vnc_init_timer(VncDisplay *vd)
{
vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
if (vd->timer == NULL && !QTAILQ_EMPTY(&vd->clients)) {
vd->timer = qemu_new_timer(rt_clock, vnc_refresh, vd);
vnc_dpy_resize(vd->ds);
vnc_refresh(vd);
}
}
| 16,643 |
qemu | e1f8c729fa890c67bb4532f22c22ace6fb0e1aaf | 0 | static int pxa2xx_pic_load(QEMUFile *f, void *opaque, int version_id)
{
PXA2xxPICState *s = (PXA2xxPICState *) opaque;
int i;
for (i = 0; i < 2; i ++)
qemu_get_be32s(f, &s->int_enabled[i]);
for (i = 0; i < 2; i ++)
qemu_get_be32s(f, &s->int_pending[i]);
for (i = 0; i < 2; i... | 16,644 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static void lsi_mmio_write(void *opaque, target_phys_addr_t addr,
uint64_t val, unsigned size)
{
LSIState *s = opaque;
lsi_reg_writeb(s, addr & 0xff, val);
}
| 16,645 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static void pmac_ide_writew (void *opaque,
target_phys_addr_t addr, uint32_t val)
{
MACIOIDEState *d = opaque;
addr = (addr & 0xFFF) >> 4;
val = bswap16(val);
if (addr == 0) {
ide_data_writew(&d->bus, 0, val);
}
}
| 16,646 |
FFmpeg | c89658008705d949c319df3fa6f400c481ad73e1 | 0 | make_setup_request (AVFormatContext *s, const char *host, int port,
int lower_transport, const char *real_challenge)
{
RTSPState *rt = s->priv_data;
int rtx, j, i, err, interleave = 0;
RTSPStream *rtsp_st;
RTSPMessageHeader reply1, *reply = &reply1;
char cmd[2048];
co... | 16,647 |
qemu | 03010579835a17450693888f8b35a66817668d68 | 0 | static void test_dst_table(AcpiSdtTable *sdt_table, uint32_t addr)
{
uint8_t checksum;
memset(sdt_table, 0, sizeof(*sdt_table));
ACPI_READ_TABLE_HEADER(&sdt_table->header, addr);
sdt_table->aml_len = le32_to_cpu(sdt_table->header.length)
- sizeof(AcpiTableHeader);
... | 16,649 |
qemu | 2bed1ba77fae50bc8b5e68ede2d80b652b30c3b8 | 0 | static void piix4_device_plug_cb(HotplugHandler *hotplug_dev,
DeviceState *dev, Error **errp)
{
PIIX4PMState *s = PIIX4_PM(hotplug_dev);
if (s->acpi_memory_hotplug.is_enabled &&
object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) {
if (object_dynamic_cast(OBJ... | 16,650 |
FFmpeg | 8083332c2de9ee189f96844ff4c2d9be1844116f | 0 | static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *buf)
{
AVFilterContext *ctx = inlink->dst;
ASyncContext *s = ctx->priv;
AVFilterLink *outlink = ctx->outputs[0];
int nb_channels = av_get_channel_layout_nb_channels(buf->audio->channel_layout);
int64_t pts = (buf->pts == A... | 16,652 |
qemu | b4ba67d9a702507793c2724e56f98e9b0f7be02b | 1 | static void test_tco2_status_bits(void)
{
TestData d;
uint16_t ticks = 8;
uint16_t val;
int ret;
d.args = NULL;
d.noreboot = true;
test_init(&d);
stop_tco(&d);
clear_tco_status(&d);
reset_on_second_timeout(true);
set_tco_timeout(&d, ticks);
load_tco(&d);
... | 16,653 |
FFmpeg | 6a63ff19b6a7fe3bc32c7fb4a62fca8f65786432 | 0 | static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
{
AVStream *st = c->fc->streams[c->fc->nb_streams-1];
MOVStreamContext *sc = st->priv_data;
int j, entries, pseudo_stream_id;
get_byte(pb); /* version */
get_be24(pb); /* flags */
entries = get_be32(pb);
f... | 16,654 |
FFmpeg | 7f526efd17973ec6d2204f7a47b6923e2be31363 | 1 | void rgb15tobgr24(const uint8_t *src, uint8_t *dst, unsigned int src_size)
{
const uint16_t *end;
uint8_t *d = (uint8_t *)dst;
const uint16_t *s = (uint16_t *)src;
end = s + src_size/2;
while(s < end)
{
register uint16_t bgr;
bgr = *s++;
*d++ = (bgr&0x7C00)>>7;
*d++ = (bgr&0x3E0)>>2;
*d++ = ... | 16,655 |
FFmpeg | d8dccf69ff2df7014a2bb8e0e17828a820f45b27 | 1 | int av_buffersink_get_samples(AVFilterContext *ctx, AVFrame *frame, int nb_samples)
{
BufferSinkContext *s = ctx->priv;
AVFilterLink *link = ctx->inputs[0];
AVFrame *cur_frame;
int ret = 0;
if (!s->audio_fifo) {
int nb_channels = link->channels;
if (!(s->audio_fifo = av_a... | 16,656 |
FFmpeg | c966c91279f8bca0f1d4865779519b077a2221f0 | 1 | static int rtsp_parse_request(HTTPContext *c)
{
const char *p, *p1, *p2;
char cmd[32];
char url[1024];
char protocol[32];
char line[1024];
int len;
RTSPMessageHeader header1, *header = &header1;
c->buffer_ptr[0] = '\0';
p = c->buffer;
get_word(cmd, sizeof(cmd), &p)... | 16,657 |
qemu | 29979a8d2596d33b474c11efb376ed47ba1d44d3 | 1 | void cpu_dump_state (CPUPPCState *env, FILE *f, fprintf_function cpu_fprintf,
int flags)
{
#define RGPL 4
#define RFPL 4
int i;
cpu_fprintf(f, "NIP " TARGET_FMT_lx " LR " TARGET_FMT_lx " CTR "
TARGET_FMT_lx " XER " TARGET_FMT_lx "\n",
env->nip, env->lr, e... | 16,658 |
qemu | 1108b2f8a939fb5778d384149e2f1b99062a72da | 1 | pvscsi_init_msi(PVSCSIState *s)
{
int res;
PCIDevice *d = PCI_DEVICE(s);
res = msi_init(d, PVSCSI_MSI_OFFSET(s), PVSCSI_MSIX_NUM_VECTORS,
PVSCSI_USE_64BIT, PVSCSI_PER_VECTOR_MASK);
if (res < 0) {
trace_pvscsi_init_msi_fail(res);
s->msi_used = false;
} el... | 16,661 |
FFmpeg | 0764fe1d09833ae4dcf9e427df09378d0d6a3386 | 1 | static void map_val_34_to_20(INTFLOAT par[PS_MAX_NR_IIDICC])
{
#if USE_FIXED
par[ 0] = (int)(((int64_t)(par[ 0] + (par[ 1]>>1)) * 1431655765 + \
0x40000000) >> 31);
par[ 1] = (int)(((int64_t)((par[ 1]>>1) + par[ 2]) * 1431655765 + \
0x40000000) >> 31);
par[... | 16,662 |
qemu | 895b00f62a7e86724dc7352d67c7808d37366130 | 1 | GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64,
bool has_count, int64_t count,
Error **errp)
{
GuestFileWrite *write_data = NULL;
guchar *buf;
gsize buf_len;
int write_count;
GuestFileHandle *gfh = gu... | 16,663 |
FFmpeg | f6774f905fb3cfdc319523ac640be30b14c1bc55 | 1 | static void fill_picture_parameters(AVCodecContext *avctx,
struct dxva_context *ctx, const VC1Context *v,
DXVA_PictureParameters *pp)
{
const MpegEncContext *s = &v->s;
const Picture *current_picture = s->current_picture_ptr;
me... | 16,665 |
FFmpeg | d549f026d8b64b879c3ce3b8c7d153c82aa5eb52 | 1 | static av_always_inline void sbr_hf_apply_noise(int (*Y)[2],
const SoftFloat *s_m,
const SoftFloat *q_filt,
int noise,
int p... | 16,667 |
FFmpeg | a03a642d5ceb5f2f7c6ebbf56ff365dfbcdb65eb | 1 | av_cold void ff_h264dsp_init_ppc(H264DSPContext *c, const int bit_depth,
const int chroma_format_idc)
{
#if HAVE_ALTIVEC
if (!(av_get_cpu_flags() & AV_CPU_FLAG_ALTIVEC))
return;
if (bit_depth == 8) {
c->h264_idct_add = h264_idct_add_altivec;
if ... | 16,668 |
FFmpeg | 6dc7dd7af45aa1e341b471fd054f85ae2747775b | 1 | static av_cold int atrac1_decode_init(AVCodecContext *avctx)
{
AT1Ctx *q = avctx->priv_data;
avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
if (avctx->channels < 1 || avctx->channels > AT1_MAX_CHANNELS) {
av_log(avctx, AV_LOG_ERROR, "Unsupported number of channels: %d\n",
avctx->cha... | 16,669 |
FFmpeg | 63a99622876ff79a07862167f243a7d3823b7315 | 1 | static int query_formats(AVFilterContext *ctx)
{
AVFilterFormats *formats = NULL;
int fmt;
for (fmt = 0; fmt < AV_PIX_FMT_NB; fmt++) {
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
if (!(desc->flags & PIX_FMT_PAL ||
fmt == AV_PIX_FMT_NV21 ||
fmt... | 16,670 |
qemu | f8df5f922152a47b3889921d249e00dab766d950 | 1 | Object *container_get(Object *root, const char *path)
{
Object *obj, *child;
gchar **parts;
int i;
parts = g_strsplit(path, "/", 0);
assert(parts != NULL && parts[0] != NULL && !parts[0][0]);
obj = root;
for (i = 1; parts[i] != NULL; i++, obj = child) {
child = object_re... | 16,671 |
FFmpeg | 01a0283c92b124f185ce4e814a1c5b600f1135e0 | 1 | int ff_h264_decode_ref_pic_list_reordering(H264Context *h){
int list, index, pic_structure, i;
print_short_term(h);
print_long_term(h);
for(list=0; list<h->list_count; list++){
for (i = 0; i < h->ref_count[list]; i++)
COPY_PICTURE(&h->ref_list[list][i], &h->default_ref_list... | 16,672 |
qemu | 113fe792fd4931dd0538f03859278b8719ee4fa2 | 1 | static void nfs_client_close(NFSClient *client)
{
if (client->context) {
if (client->fh) {
nfs_close(client->context, client->fh);
}
aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context),
false, NULL, NULL, NULL, NULL);
nfs... | 16,673 |
qemu | e23a1b33b53d25510320b26d9f154e19c6c99725 | 1 | static void musicpal_init(ram_addr_t ram_size,
const char *boot_device,
const char *kernel_filename, const char *kernel_cmdline,
const char *initrd_filename, const char *cpu_model)
{
CPUState *env;
qemu_irq *cpu_pic;
qemu_irq pic[32];
DeviceState *dev... | 16,674 |
qemu | 57d1f6d7ce23e79a8ebe4a57bd2363b269b4664b | 1 | size_t qemu_mempath_getpagesize(const char *mem_path)
{
#ifdef CONFIG_LINUX
struct statfs fs;
int ret;
do {
ret = statfs(mem_path, &fs);
} while (ret != 0 && errno == EINTR);
if (ret != 0) {
fprintf(stderr, "Couldn't statfs() memory path: %s\n",
strerror... | 16,675 |
qemu | 8ffaaba0e939f2a284bb23d1f6f7f9e2104a97e2 | 1 | static int nbd_send_negotiate(NBDClient *client)
{
int csock = client->sock;
char buf[8 + 8 + 8 + 128];
int rc;
const int myflags = (NBD_FLAG_HAS_FLAGS | NBD_FLAG_SEND_TRIM |
NBD_FLAG_SEND_FLUSH | NBD_FLAG_SEND_FUA);
/* Negotiation header without options:
[... | 16,676 |
FFmpeg | 9244b839b788e4677019041907ff5a4378a23490 | 1 | static void dmix_sub_c(int32_t *dst, const int32_t *src, int coeff, ptrdiff_t len)
{
int i;
for (i = 0; i < len; i++)
dst[i] -= mul15(src[i], coeff);
}
| 16,677 |
FFmpeg | 75f418064ecf5c2713151cbe6b3a716d2c047f1d | 1 | static int read_seek(AVFormatContext *s, int stream_index,
int64_t timestamp, int flags)
{
AVStream *st = s->streams[0];
CaffContext *caf = s->priv_data;
int64_t pos;
timestamp = FFMAX(timestamp, 0);
if (caf->frames_per_packet > 0 && caf->bytes_per_packet > 0) {
... | 16,678 |
FFmpeg | 6a0cd529a35190d9374b0b26504e71857cd67b83 | 1 | static int tta_read_header(AVFormatContext *s)
{
TTAContext *c = s->priv_data;
AVStream *st;
int i, channels, bps, samplerate;
uint64_t framepos, start_offset;
uint32_t nb_samples, crc;
ff_id3v1_read(s);
start_offset = avio_tell(s->pb);
ffio_init_checksum(s->pb, tta_check_cr... | 16,679 |
FFmpeg | 55eda370cb6fe9e4c21539f3f90fd940fcf7a103 | 1 | static int planarCopyWrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
int srcSliceH, uint8_t* dst[], int dstStride[])
{
int plane, i, j;
for (plane=0; plane<4; plane++) {
int length= (plane==0 || plane==3) ? c->srcW : -((-c->srcW )>>c->chrD... | 16,680 |
qemu | b4176cb314995ad225d6c2b531568801feb04f3f | 1 | static int nbd_co_receive_offset_data_payload(NBDClientSession *s,
uint64_t orig_offset,
QEMUIOVector *qiov, Error **errp)
{
QEMUIOVector sub_qiov;
uint64_t offset;
size_t data_size;
int ret;
NBDStruc... | 16,681 |
qemu | c976437c7dba9c7444fb41df45468968aaa326ad | 1 | void xen_pt_msi_disable(XenPCIPassthroughState *s)
{
XenPTMSI *msi = s->msi;
if (!msi) {
return;
}
xen_pt_msi_set_enable(s, false);
msi_msix_disable(s, msi_addr64(msi), msi->data, msi->pirq, false,
msi->initialized);
/* clear msi info */
msi->fl... | 16,682 |
FFmpeg | 2da0d70d5eebe42f9fcd27ee554419ebe2a5da06 | 1 | static inline void RENAME(hScale)(int16_t *dst, int dstW, uint8_t *src, int srcW, int xInc,
int16_t *filter, int16_t *filterPos, long filterSize)
{
#ifdef HAVE_MMX
assert(filterSize % 4 == 0 && filterSize>0);
if(filterSize==4) // Always true for upscaling, sometimes for down, too.
{
long counter= -2*d... | 16,683 |
FFmpeg | bba9d8bdfb208b0ec2ccf182530347151ee3528b | 1 | static void qpeg_decode_inter(QpegContext *qctx, uint8_t *dst,
int stride, int width, int height,
int delta, const uint8_t *ctable,
uint8_t *refdata)
{
int i, j;
int code;
int filled = 0;
int orig_height;
... | 16,684 |
FFmpeg | decae20f3662650ecb9602c0c760af275a1e7db3 | 1 | static int unpack(const uint8_t *src, const uint8_t *src_end, unsigned char *dst, int width, int height) {
unsigned char *dst_end = dst + width*height;
int size,size1,size2,offset,run;
unsigned char *dst_start = dst;
if (src[0] & 0x01)
src += 5;
else
src += 2;
if (src... | 16,686 |
qemu | 9c75e168bc388094c04aabb6fc59c91abe06e81c | 1 | void qmp_block_resize(bool has_device, const char *device,
bool has_node_name, const char *node_name,
int64_t size, Error **errp)
{
Error *local_err = NULL;
BlockDriverState *bs;
int ret;
bs = bdrv_lookup_bs(has_device ? device : NULL,
... | 16,687 |
qemu | 9fbf0fa81fca8f527669dd4fa72662d66e7d6329 | 1 | static int32_t bmdma_prepare_buf(IDEDMA *dma, int32_t limit)
{
BMDMAState *bm = DO_UPCAST(BMDMAState, dma, dma);
IDEState *s = bmdma_active_if(bm);
PCIDevice *pci_dev = PCI_DEVICE(bm->pci_dev);
struct {
uint32_t addr;
uint32_t size;
} prd;
int l, len;
pci_dma_sgli... | 16,688 |
FFmpeg | 6e42e6c4b410dbef8b593c2d796a5dad95f89ee4 | 1 | static inline void RENAME(yvu9toyv12)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc,
uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
long width, long height, long lumStride, long chromStride)
{
/* Y Plane */
memcpy(ydst, ysrc, width*height);
/* XXX: implement upscaling for U,V */
}
| 16,689 |
qemu | e1cf5582644ef63528993fb2b88dd3b43b9914c6 | 1 | void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len)
{
assert(qiov->nalloc != -1);
if (qiov->niov == qiov->nalloc) {
qiov->nalloc = 2 * qiov->nalloc + 1;
qiov->iov = g_realloc(qiov->iov, qiov->nalloc * sizeof(struct iovec));
}
qiov->iov[qiov->niov].iov_base = base;
... | 16,690 |
FFmpeg | 4ff94558f23a5de43aed4ca3429963dd1d995250 | 1 | int ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
{
if (ctb_addr_ts == s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]) {
int ret = cabac_init_decoder(s);
if (ret < 0)
return ret;
if (s->sh.dependent_slice_segment_flag == 0 ||
(s->ps.pps->tiles_enab... | 16,691 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.