id int32 0 27.3k | func stringlengths 26 142k | target bool 2
classes | project stringclasses 2
values | commit_id stringlengths 40 40 |
|---|---|---|---|---|
3,548 | int avpriv_dv_produce_packet(DVDemuxContext *c, AVPacket *pkt,
uint8_t *buf, int buf_size)
{
int size, i;
uint8_t *ppcm[4] = { 0 };
if (buf_size < DV_PROFILE_BYTES ||
!(c->sys = avpriv_dv_frame_profile(c->sys, buf, buf_size)) ||
buf_size < c->sys->frame_... | true | FFmpeg | 7ee191cab0dc44700f26c5784e2adeb6a779651b |
3,549 | static void handle_event(int event)
{
static bool logged;
if (event & ~PVPANIC_PANICKED && !logged) {
qemu_log_mask(LOG_GUEST_ERROR, "pvpanic: unknown event %#x.\n", event);
logged = true;
}
if (event & PVPANIC_PANICKED) {
panicked_mon_event("pause");
vm_stop... | true | qemu | 3a4496903795e05c1e8367bb4c9862d5670f48d7 |
3,550 | static void *iothread_run(void *opaque)
{
IOThread *iothread = opaque;
rcu_register_thread();
my_iothread = iothread;
qemu_mutex_lock(&iothread->init_done_lock);
iothread->thread_id = qemu_get_thread_id();
qemu_cond_signal(&iothread->init_done_cond);
qemu_mutex_unlock(&iothread->... | true | qemu | 2362a28ea11c145e1a13ae79342d76dc118a72a6 |
3,552 | static void omap_rtc_write(void *opaque, hwaddr addr,
uint64_t value, unsigned size)
{
struct omap_rtc_s *s = (struct omap_rtc_s *) opaque;
int offset = addr & OMAP_MPUI_REG_MASK;
struct tm new_tm;
time_t ti[2];
if (size != 1) {
return omap_badwidth_write... | true | qemu | 7e7e5858f83ae711b08d11e2268c6fc6f8385fb7 |
3,553 | static void neon_store_reg(int reg, int pass, TCGv var)
{
tcg_gen_st_i32(var, cpu_env, neon_reg_offset(reg, pass));
dead_tmp(var);
}
| true | qemu | 7d1b0095bff7157e856d1d0e6c4295641ced2752 |
3,554 | static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
{
int b, prefixes, aflag, dflag;
int shift, ot;
int modrm, reg, rm, mod, reg_addr, op, opreg, offset_addr, val;
target_ulong next_eip, tval;
int rex_w, rex_r;
if (unlikely(loglevel & CPU_LOG_TB_OP))
tcg_gen_... | true | qemu | 32938e127f50a40844a0fb9c5abb8691aeeccf7e |
3,556 | static void align_position(AVIOContext *pb, int64_t offset, uint64_t size)
{
if (avio_tell(pb) != offset + size)
avio_seek(pb, offset + size, SEEK_SET);
}
| true | FFmpeg | 74474750f1ac522730dae271a5ea5003caa8b73c |
3,557 | static int usb_serial_handle_data(USBDevice *dev, USBPacket *p)
{
USBSerialState *s = (USBSerialState *)dev;
int ret = 0;
uint8_t devep = p->devep;
uint8_t *data = p->data;
int len = p->len;
int first_len;
switch (p->pid) {
case USB_TOKEN_OUT:
if (devep != 2)
... | true | qemu | 4f4321c11ff6e98583846bfd6f0e81954924b003 |
3,558 | void isa_register_portio_list(ISADevice *dev, uint16_t start,
const MemoryRegionPortio *pio_start,
void *opaque, const char *name)
{
PortioList piolist;
/* START is how we should treat DEV, regardless of the actual
contents of the portio... | true | qemu | e305a16510afa74eec20390479e349402e55ef4c |
3,559 | static inline void write_mem(IVState *s, uint64_t off,
const void *buf, size_t len)
{
QTestState *qtest = global_qtest;
global_qtest = s->qtest;
qpci_memwrite(s->dev, s->mem_base + off, buf, len);
global_qtest = qtest;
}
| true | qemu | b4ba67d9a702507793c2724e56f98e9b0f7be02b |
3,562 | static void qemu_mod_timer_ns(QEMUTimer *ts, int64_t expire_time)
{
QEMUTimer **pt, *t;
qemu_del_timer(ts);
/* add the timer in the sorted list */
/* NOTE: this code must be signal safe because
qemu_timer_expired() can be called from a signal. */
pt = &active_timers[ts->clock->type... | true | qemu | ab33fcda9f96b9195dfb3fcf5bd9bb5383caeaea |
3,563 | static void co_read_response(void *opaque)
{
BDRVSheepdogState *s = opaque;
if (!s->co_recv) {
s->co_recv = qemu_coroutine_create(aio_read_response);
}
qemu_coroutine_enter(s->co_recv, opaque);
}
| true | qemu | 0b8b8753e4d94901627b3e86431230f2319215c4 |
3,564 | static void omap2_inth_write(void *opaque, target_phys_addr_t addr,
uint64_t value, unsigned size)
{
struct omap_intr_handler_s *s = (struct omap_intr_handler_s *) opaque;
int offset = addr;
int bank_no, line_no;
struct omap_intr_handler_bank_s *bank = NULL;
if ... | true | qemu | 096685fc2a955ea17d5363ab452e301be2b43873 |
3,565 | static int decode_hextile(VmncContext *c, uint8_t* dst, uint8_t* src, int w, int h, int stride)
{
int i, j, k;
int bg = 0, fg = 0, rects, color, flags, xy, wh;
const int bpp = c->bpp2;
uint8_t *dst2;
int bw = 16, bh = 16;
uint8_t *ssrc=src;
for(j = 0; j < h; j += 16) {
dst... | true | FFmpeg | 096bc417ae9b5bf35631d48fbc798020aac08aee |
3,567 | static void filter_mb_mbaff_edgev( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int bsi, int qp ) {
int i;
int index_a = qp + h->slice_alpha_c0_offset;
int alpha = (alpha_table+52)[index_a];
int beta = (beta_table+52)[qp + h->slice_beta_offset];
for( i = 0; i < 8; i++, pix += strid... | false | FFmpeg | 0c32e19d584ba6ddbc27f0a796260404daaf4b6a |
3,570 | static void arm_idct_add(UINT8 *dest, int line_size, DCTELEM *block)
{
j_rev_dct_ARM (block);
add_pixels_clamped(block, dest, line_size);
}
| false | FFmpeg | 83f238cbf0c038245d2b2dffa5beb0916e7c36d2 |
3,571 | static inline void decode_block_intra(MadContext * t, DCTELEM * block)
{
MpegEncContext *s = &t->s;
int level, i, j, run;
RLTable *rl = &ff_rl_mpeg1;
const uint8_t *scantable = s->intra_scantable.permutated;
int16_t *quant_matrix = s->intra_matrix;
block[0] = (128 + get_sbits(&s->gb, 8)... | false | FFmpeg | 1d0ae92a259b924952856de1a5ca0dc6fd5031e5 |
3,572 | static void test_ivshmem_memdev(void)
{
IVState state;
/* just for the sake of checking memory-backend property */
setup_vm_cmd(&state, "-object memory-backend-ram,size=1M,id=mb1"
" -device ivshmem,x-memdev=mb1", false);
qtest_quit(state.qtest);
}
| true | qemu | 1760048a5d21bacf0e4838da2f61b2d8db7d2866 |
3,573 | static av_cold void init_static(void)
{
if (!huff_vlc[0].bits) {
INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
&ff_mlp_huffman_tables[0][0][1], 2, 1,
&ff_mlp_huffman_tables[0][0][0], 2, 1, 512);
INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
&ff_mlp_huffman_... | true | FFmpeg | 7fd88069241ead2d2fd3e2db1b79e4b292e90001 |
3,574 | void gen_pc_load(CPUState *env, TranslationBlock *tb,
unsigned long searched_pc, int pc_pos, void *puc)
{
env->regs[15] = gen_opc_pc[pc_pos];
} | true | qemu | e12ce78d4aa05ccf80d6a843a9227042647db39d |
3,575 | void virtio_scsi_dataplane_notify(VirtIODevice *vdev, VirtIOSCSIReq *req)
{
if (virtio_should_notify(vdev, req->vq)) {
event_notifier_set(virtio_queue_get_guest_notifier(req->vq));
}
}
| true | qemu | 83d768b5640946b7da55ce8335509df297e2c7cd |
3,576 | SwsFunc ff_yuv2rgb_init_mmx(SwsContext *c)
{
int cpu_flags = av_get_cpu_flags();
if (c->srcFormat != PIX_FMT_YUV420P &&
c->srcFormat != PIX_FMT_YUVA420P)
return NULL;
if (HAVE_MMX2 && cpu_flags & AV_CPU_FLAG_MMX2) {
switch (c->dstFormat) {
case PIX_FMT_RGB24: ret... | true | FFmpeg | 39d607e5bbc25ad9629683702b510e865434ef21 |
3,577 | int ide_init_drive(IDEState *s, BlockDriverState *bs,
const char *version, const char *serial)
{
int cylinders, heads, secs;
uint64_t nb_sectors;
s->bs = bs;
bdrv_get_geometry(bs, &nb_sectors);
bdrv_guess_geometry(bs, &cylinders, &heads, &secs);
if (cylinders < 1 || ... | true | qemu | 98f28ad7a7d26e5e77c5cb37b262d76d6ccd963d |
3,578 | SCSIDevice *scsi_bus_legacy_add_drive(SCSIBus *bus, BlockDriverState *bdrv,
int unit, bool removable, int bootindex,
const char *serial, Error **errp)
{
const char *driver;
DeviceState *dev;
Error *err = NULL;
driver = ... | true | qemu | c24e7517ee4a98e90eee5f0f07708a1fa12326b3 |
3,579 | static int unix_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
{
QEMUFileSocket *s = opaque;
ssize_t len;
for (;;) {
len = read(s->fd, buf, size);
if (len != -1) {
break;
}
if (errno == EAGAIN) {
yield_until_fd_readable(s->fd... | true | qemu | 60fe637bf0e4d7989e21e50f52526444765c63b4 |
3,580 | DriveInfo *add_init_drive(const char *optstr)
{
DriveInfo *dinfo;
QemuOpts *opts;
MachineClass *mc;
opts = drive_def(optstr);
if (!opts)
return NULL;
mc = MACHINE_GET_CLASS(current_machine);
dinfo = drive_new(opts, mc->block_default_type);
if (!dinfo) {
qem... | true | qemu | f51074cdc6e750daa3b6df727d83449a7e42b391 |
3,581 | static void decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src, int log2w, int log2h, int stride){
const int index= size2index[log2h][log2w];
const int h= 1<<log2h;
int code= get_vlc2(&f->gb, block_type_vlc[1-(f->version>1)][index].table, BLOCK_TYPE_VLC_BITS, 1);
uint16_t *start= (uint16_t... | true | FFmpeg | 1443ea93d935784370f41d85e224718484b0e32c |
3,583 | static int mov_write_int8_metadata(AVFormatContext *s, AVIOContext *pb,
const char *name, const char *tag,
int len)
{
AVDictionaryEntry *t = NULL;
uint8_t num;
if (!(t = av_dict_get(s->metadata, tag, NULL, 0)))
return 0;
... | false | FFmpeg | 5f531386210e844f0a6819404cde58da54c46a00 |
3,584 | int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
const uint8_t *buf, int len)
{
unsigned int ssrc, h;
int payload_type, seq, ret;
AVStream *st;
uint32_t timestamp;
int rv= 0;
if (!buf) {
/* return the next packets, if any */
if(s->st && s->... | false | FFmpeg | 4a6cc06123d969fe3214ff874bc87c1aec529143 |
3,586 | static int decode_mb_info(IVI4DecContext *ctx, IVIBandDesc *band,
IVITile *tile, AVCodecContext *avctx)
{
int x, y, mv_x, mv_y, mv_delta, offs, mb_offset, blks_per_mb,
mv_scale, mb_type_bits, s;
IVIMbInfo *mb, *ref_mb;
int row_offset = band->... | true | FFmpeg | 5216245a2c5ed8140d99f14fcc148fbb6db9831e |
3,587 | static int balloon_parse(const char *arg)
{
QemuOpts *opts;
if (strcmp(arg, "none") == 0) {
return 0;
}
if (!strncmp(arg, "virtio", 6)) {
if (arg[6] == ',') {
/* have params -> parse them */
opts = qemu_opts_parse(qemu_find_opts("device"), arg+7, 0);
... | true | qemu | 8be7e7e4c72c048b90e3482557954a24bba43ba7 |
3,588 | static inline void RENAME(yuv2yuvX)(SwsContext *c, int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize,
int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize,
uint8_t *dest, uint8_t *uDest, uint8_t *vDest, int dstW, int chrDstW)
{
#ifdef HAVE_MMX
if(uDest != NULL)
{
asm volatile(
Y... | true | FFmpeg | 7f526efd17973ec6d2204f7a47b6923e2be31363 |
3,589 | int attribute_align_arg avcodec_decode_audio2(AVCodecContext *avctx, int16_t *samples,
int *frame_size_ptr,
uint8_t *buf, int buf_size)
{
int ret;
if((avctx->codec->capabilities & CODEC_CAP_DELAY) || buf_size){
//FIXME remove the check below _aft... | false | FFmpeg | 81fc2f37db98b3472bf997e5f302e65d75670f3e |
3,590 | static void nbd_co_receive_reply(NBDClientSession *s,
NBDRequest *request,
NBDReply *reply,
QEMUIOVector *qiov)
{
int ret;
/* Wait until we're woken up by nbd_read_reply_entry. */
qemu_coroutine_yiel... | true | qemu | 72b6ffc76653214b69a94a7b1643ff80df134486 |
3,591 | static const char *local_mapped_attr_path(FsContext *ctx,
const char *path, char *buffer)
{
char *dir_name;
char *tmp_path = strdup(path);
char *base_name = basename(tmp_path);
/* NULL terminate the directory */
dir_name = tmp_path;
*(base_name... | true | qemu | d3f8e138c23ba082f87c96634d06b978473c1e9b |
3,592 | void usb_host_info(Monitor *mon, const QDict *qdict)
{
libusb_device **devs;
struct libusb_device_descriptor ddesc;
char port[16];
int i, n;
if (usb_host_init() != 0) {
return;
}
n = libusb_get_device_list(ctx, &devs);
for (i = 0; i < n; i++) {
if (libusb_g... | true | qemu | 3ce21445387c64032a21ae73c995195307a28a36 |
3,593 | static void gen_mulldo(DisasContext *ctx)
{
TCGv_i64 t0 = tcg_temp_new_i64();
TCGv_i64 t1 = tcg_temp_new_i64();
tcg_gen_muls2_i64(t0, t1, cpu_gpr[rA(ctx->opcode)],
cpu_gpr[rB(ctx->opcode)]);
tcg_gen_mov_i64(cpu_gpr[rD(ctx->opcode)], t0);
tcg_gen_sari_i64(t0, t0, 63);... | true | qemu | 61aa9a697a1ec9b102e86cb7ea96876e6f20afe3 |
3,594 | static inline target_phys_addr_t get_pgaddr (target_phys_addr_t sdr1,
int sdr_sh,
target_phys_addr_t hash,
target_phys_addr_t mask)
{
return (sdr1 & ((target_ulong)(-1ULL) << s... | true | qemu | 12de9a396acbc95e25c5d60ed097cc55777eaaed |
3,595 | static unsigned int mszh_decomp(const unsigned char * srcptr, int srclen, unsigned char * destptr, unsigned int destsize)
{
unsigned char *destptr_bak = destptr;
unsigned char *destptr_end = destptr + destsize;
const unsigned char *srcptr_end = srcptr + srclen;
unsigned mask = *srcptr++;
unsig... | true | FFmpeg | 42a1f1d7a8cf67eed68db596d6a1e53c0c36e4ab |
3,597 | static uint32_t unassigned_mem_readb(void *opaque, target_phys_addr_t addr)
{
#ifdef DEBUG_UNASSIGNED
printf("Unassigned mem read " TARGET_FMT_plx "\n", addr);
#endif
#if defined(TARGET_ALPHA) || defined(TARGET_SPARC) || defined(TARGET_MICROBLAZE)
do_unassigned_access(addr, 0, 0, 0, 1);
#endif
retur... | true | qemu | b14ef7c9ab41ea824c3ccadb070ad95567cca84e |
3,599 | static int mxg_update_cache(AVFormatContext *s, unsigned int cache_size)
{
MXGContext *mxg = s->priv_data;
unsigned int current_pos = mxg->buffer_ptr - mxg->buffer;
unsigned int soi_pos;
int ret;
/* reallocate internal buffer */
if (current_pos > current_pos + cache_size)
retur... | true | FFmpeg | a72b41035cc4925922b4164b7453c9a5c2b7e630 |
3,601 | vubr_set_mem_table_exec(VubrDev *dev, VhostUserMsg *vmsg)
{
int i;
VhostUserMemory *memory = &vmsg->payload.memory;
dev->nregions = memory->nregions;
DPRINT("Nregions: %d\n", memory->nregions);
for (i = 0; i < dev->nregions; i++) {
void *mmap_addr;
VhostUserMemoryRegion *ms... | true | qemu | 6d0b908a628a7086fa855c68b217cc1e2a5c4c19 |
3,603 | static av_cold int dilate_init(AVFilterContext *ctx, const char *args)
{
OCVContext *s = ctx->priv;
DilateContext *dilate = s->priv;
char default_kernel_str[] = "3x3+0x0/rect";
char *kernel_str;
const char *buf = args;
int ret;
dilate->nb_iterations = 1;
if (args)
k... | false | FFmpeg | a6653787a4b1e89170ff7962312dd110769c83a3 |
3,604 | static int transcode(OutputFile *output_files,
int nb_output_files,
InputFile *input_files,
int nb_input_files)
{
int ret = 0, i;
AVFormatContext *is, *os;
AVCodecContext *codec, *icodec;
OutputStream *ost;
InputStream *ist;
... | false | FFmpeg | 93ed69ad2103e0c58ebcaa80dd55742d75f8c461 |
3,605 | static int dvvideo_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
uint8_t *buf, int buf_size)
{
DVVideoContext *s = avctx->priv_data;
/* special case for last picture */
if(buf_size==0)
return 0;
... | false | FFmpeg | 934982c4ace1a3d5d627b518782ed092a456c49e |
3,606 | rdt_parse_packet (PayloadContext *rdt, AVStream *st,
AVPacket *pkt, uint32_t *timestamp,
const uint8_t *buf, int len, int flags)
{
int seq = 1, res;
ByteIOContext pb;
if (rdt->audio_pkt_cnt == 0) {
int pos;
init_put_byte(&pb, buf, len, 0, NULL,... | false | FFmpeg | 5d88c2647def2557637077e9284cfe9806954502 |
3,607 | static void FUNC(hevc_v_loop_filter_luma)(uint8_t *pix, ptrdiff_t stride,
int *beta, int *tc, uint8_t *no_p,
uint8_t *no_q)
{
FUNC(hevc_loop_filter_luma)(pix, sizeof(pixel), stride,
beta, tc, no_... | false | FFmpeg | 73bb8f61d48dbf7237df2e9cacd037f12b84b00a |
3,608 | static int http_server(void)
{
int server_fd, ret, rtsp_server_fd, delay, delay1;
struct pollfd poll_table[HTTP_MAX_CONNECTIONS + 2], *poll_entry;
HTTPContext *c, *c_next;
server_fd = socket_open_listen(&my_http_addr);
if (server_fd < 0)
return -1;
rtsp_server_fd = socket_ope... | false | FFmpeg | e8d658df344553170cc1302438a8e70d97b52169 |
3,609 | static int h264_field_start(H264Context *h, const H264SliceContext *sl,
const H2645NAL *nal, int first_slice)
{
int i;
const SPS *sps;
int last_pic_structure, last_pic_droppable, ret;
ret = h264_init_ps(h, sl, first_slice);
if (ret < 0)
return ret;
... | true | FFmpeg | 083300bea935d125b83f60d7030f78a7ffb0f3df |
3,612 | void fork_start(void)
{
mmap_fork_start();
qemu_mutex_lock(&tb_ctx.tb_lock);
cpu_list_lock();
} | true | qemu | 06065c451f10c7ef62cfb575a87f323a70ae1c9e |
3,613 | static int config_output(AVFilterLink *outlink)
{
AVFilterContext *ctx = outlink->src;
LIBVMAFContext *s = ctx->priv;
AVFilterLink *mainlink = ctx->inputs[0];
int ret;
outlink->w = mainlink->w;
outlink->h = mainlink->h;
outlink->time_base = mainlink->time_base;
outlink->sample... | true | FFmpeg | a8ab52fae7286d4e7eec9256a08b6ad0b1e39d6c |
3,614 | void h263_encode_mb(MpegEncContext * s,
DCTELEM block[6][64],
int motion_x, int motion_y)
{
int cbpc, cbpy, i, cbp, pred_x, pred_y;
// printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
if (!s->mb_intra) {
/* compute cbp */
cbp = 0;
for (i = 0; i < 6; i++) {
if (s->bl... | true | FFmpeg | 544286b3d39365b30298ae07e66a755200b0895c |
3,615 | static int decode_band(IVI5DecContext *ctx, int plane_num,
IVIBandDesc *band, AVCodecContext *avctx)
{
int result, i, t, idx1, idx2;
IVITile *tile;
band->buf = band->bufs[ctx->dst_buf];
band->ref_buf = band->bufs[ctx->ref_buf];
band->data_ptr = ctx->fr... | false | FFmpeg | 7fcb98a7ec51123ecfd810a167d96f128eed9b79 |
3,617 | static int select_reference_stream(AVFormatContext *s)
{
SegmentContext *seg = s->priv_data;
int ret, i;
seg->reference_stream_index = -1;
if (!strcmp(seg->reference_stream_specifier, "auto")) {
/* select first index of type with highest priority */
int type_index_map[AVMEDIA_TY... | true | FFmpeg | e3197257171c347353538152523f9d3fe880aee6 |
3,618 | static void property_get_tm(Object *obj, Visitor *v, const char *name,
void *opaque, Error **errp)
{
TMProperty *prop = opaque;
Error *err = NULL;
struct tm value;
prop->get(obj, &value, &err);
if (err) {
goto out;
}
visit_start_struct(v, nam... | true | qemu | 15c2f669e3fb2bc97f7b42d1871f595c0ac24af8 |
3,622 | e1000e_write_lgcy_rx_descr(E1000ECore *core, uint8_t *desc,
struct NetRxPkt *pkt,
const E1000E_RSSInfo *rss_info,
uint16_t length)
{
uint32_t status_flags, rss, mrq;
uint16_t ip_id;
struct e1000_rx_desc *d = (struct e1... | true | qemu | c89d416a2b0fb6a21224186b10af4c4a3feee31b |
3,623 | void qemu_put_byte(QEMUFile *f, int v)
{
if (f->last_error) {
return;
}
f->buf[f->buf_index] = v;
f->bytes_xfer++;
if (f->ops->writev_buffer) {
add_to_iovec(f, f->buf + f->buf_index, 1);
}
f->buf_index++;
if (f->buf_index == IO_BUF_SIZE) {
qemu_fflus... | true | qemu | 60fe637bf0e4d7989e21e50f52526444765c63b4 |
3,624 | long do_rt_sigreturn(CPUX86State *env)
{
abi_ulong frame_addr;
struct rt_sigframe *frame;
sigset_t set;
frame_addr = env->regs[R_ESP] - 4;
trace_user_do_rt_sigreturn(env, frame_addr);
if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
goto badframe;
target_to_host_s... | true | qemu | c599d4d6d6e9bfdb64e54c33a22cb26e3496b96d |
3,625 | unsigned ff_els_decode_unsigned(ElsDecCtx *ctx, ElsUnsignedRung *ur)
{
int i, n, r, bit;
ElsRungNode *rung_node;
if (ctx->err)
return 0;
/* decode unary prefix */
for (n = 0; n < ELS_EXPGOLOMB_LEN + 1; n++)
if (ff_els_decode_bit(ctx, &ur->prefix_rung[n]))
bre... | true | FFmpeg | 4e0819310e2d2eff60be2d6df28335f0739712b9 |
3,626 | static int sse_mb(MpegEncContext *s){
int w= 16;
int h= 16;
if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
if(w==16 && h==16)
if(s->avctx->mb_cmp == FF_CMP_NSSE){
return s->dsp.nsse[0](s, s->new_picture.f.... | true | FFmpeg | f6774f905fb3cfdc319523ac640be30b14c1bc55 |
3,627 | static uint64_t alloc_cluster_offset(BlockDriverState *bs,
uint64_t offset,
int n_start, int n_end,
int *num, QCowL2Meta *m)
{
BDRVQcowState *s = bs->opaque;
int l2_index, ret;
uint64_t l2_o... | true | qemu | ff4b91c2f7e51dab148aba4bf43c2f39f219e495 |
3,628 | static int dv_extract_audio(uint8_t* frame, uint8_t* ppcm[4],
const DVprofile *sys)
{
int size, chan, i, j, d, of, smpls, freq, quant, half_ch;
uint16_t lc, rc;
const uint8_t* as_pack;
uint8_t *pcm, ipcm;
as_pack = dv_extract_pack(frame, dv_audio_source);
if... | true | FFmpeg | 88d84dd8eacd4edfe29f12209f10733d631ca5ae |
3,629 | static int transcode_init(void)
{
int ret = 0, i, j, k;
AVFormatContext *oc;
AVCodecContext *codec, *icodec;
OutputStream *ost;
InputStream *ist;
char error[1024];
int want_sdp = 1;
/* init framerate emulation */
for (i = 0; i < nb_input_files; i++) {
InputFile *... | true | FFmpeg | 369cb092ecbbaff20bb0a2a1d60536c3bc04a8f0 |
3,630 | static int get_aiff_header(AVFormatContext *s, int size,
unsigned version)
{
AVIOContext *pb = s->pb;
AVCodecParameters *par = s->streams[0]->codecpar;
AIFFInputContext *aiff = s->priv_data;
int exp;
uint64_t val;
int sample_rate;
unsigned ... | true | FFmpeg | ad5807f8aa883bee5431186dc1f24c5435d722d3 |
3,631 | static void xen_init_pv(QEMUMachineInitArgs *args)
{
const char *cpu_model = args->cpu_model;
const char *kernel_filename = args->kernel_filename;
const char *kernel_cmdline = args->kernel_cmdline;
const char *initrd_filename = args->initrd_filename;
X86CPU *cpu;
CPUState *cs;
DriveI... | true | qemu | 58ee9b0ae05d81c74d6869a25ce4263fc22ed809 |
3,632 | void signal_init(void)
{
struct sigaction act;
int i;
/* set all host signal handlers. ALL signals are blocked during
the handlers to serialize them. */
sigfillset(&act.sa_mask);
act.sa_flags = SA_SIGINFO;
act.sa_sigaction = host_signal_handler;
for(i = 1; i < NSIG; i++) {
... | true | qemu | c9087c2a6068b23207517f7d7ff796e68290358b |
3,633 | static inline void gen_bx(DisasContext *s, TCGv_i32 var)
{
s->is_jmp = DISAS_UPDATE;
tcg_gen_andi_i32(cpu_R[15], var, ~1);
tcg_gen_andi_i32(var, var, 1);
store_cpu_field(var, thumb);
}
| true | qemu | 577bf808958d06497928c639efaa473bf8c5e099 |
3,635 | static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb,
int buf_size, int *coded_samples, int *approx_nb_samples)
{
ADPCMDecodeContext *s = avctx->priv_data;
int nb_samples = 0;
int ch = avctx->channels;
int has_coded_samples = 0;
i... | true | FFmpeg | 3c803ed9cb23e5a8d76b6c31d8a8c71cac27e769 |
3,636 | static void serial_receive1(void *opaque, const uint8_t *buf, int size)
{
SerialState *s = opaque;
serial_receive_byte(s, buf[0]);
}
| true | qemu | 81174dae3f9189519cd60c7b79e91c291b021bbe |
3,639 | static TCGv_i32 gen_get_asi(DisasContext *dc, int insn)
{
int asi;
if (IS_IMM) {
#ifdef TARGET_SPARC64
asi = dc->asi;
#else
gen_exception(dc, TT_ILL_INSN);
asi = 0;
#endif
} else {
asi = GET_FIELD(insn, 19, 26);
}
return tcg_const_i32(asi);
}
| false | qemu | 7ec1e5ea4bd0700fa48da86bffa2fcc6146c410a |
3,640 | static void setup_rt_frame(int sig, struct target_sigaction *ka,
target_siginfo_t *info,
target_sigset_t *set, CPUSH4State *regs)
{
struct target_rt_sigframe *frame;
abi_ulong frame_addr;
int i;
int err = 0;
int signal;
frame_addr ... | false | qemu | b0fd8d18683f0d77a8e6b482771ebea82234d727 |
3,641 | static void display_mouse_set(DisplayChangeListener *dcl,
int x, int y, int on)
{
SimpleSpiceDisplay *ssd = container_of(dcl, SimpleSpiceDisplay, dcl);
qemu_mutex_lock(&ssd->lock);
ssd->ptr_x = x;
ssd->ptr_y = y;
if (ssd->ptr_move) {
g_free(ssd->ptr_mo... | false | qemu | ef1e1e0782e99c9dcf2b35e5310cdd8ca9211374 |
3,642 | static void cpu_request_exit(void *opaque, int irq, int level)
{
CPUState *cpu = current_cpu;
if (cpu && level) {
cpu_exit(cpu);
}
}
| false | qemu | 5039d6e23586fe6bbedc5e4fe302b48a66890ade |
3,643 | int qemu_get_thread_id(void)
{
#if defined (__linux__)
return syscall(SYS_gettid);
#else
return getpid();
#endif
}
| false | qemu | cbcfa0418f0c196afa765f5c9837b9344d1adcf3 |
3,644 | static void listflags(char *buf, int bufsize, uint32_t fbits,
const char **featureset, uint32_t flags)
{
const char **p = &featureset[31];
char *q, *b, bit;
int nc;
b = 4 <= bufsize ? buf + (bufsize -= 3) - 1 : NULL;
*buf = '\0';
for (q = buf, bit = 31; fbits && bufsize; --p, fbits... | false | qemu | d354899c8279146f3e154b9ba1f7461abb7f5279 |
3,645 | void watchdog_add_model(WatchdogTimerModel *model)
{
LIST_INSERT_HEAD(&watchdog_list, model, entry);
}
| false | qemu | 72cf2d4f0e181d0d3a3122e04129c58a95da713e |
3,646 | static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h,
int stride, int plane_index)
{
int x, y, i;
const int ring_size = s->avctx->context_model ? 3 : 2;
int16_t *sample[3];
s->run_index = 0;
memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s-... | false | FFmpeg | 77f521d9e5126575f9bcc21241d81867173c7619 |
3,647 | static int decode_plane(Indeo3DecodeContext *ctx, AVCodecContext *avctx,
Plane *plane, const uint8_t *data, int32_t data_size,
int32_t strip_width)
{
Cell curr_cell;
int num_vectors;
/* each plane data starts with mc_vector_count... | false | FFmpeg | 1afe49b062a959ed0433e4fd9c1b5dff829ae03e |
3,648 | int qemu_savevm_state_iterate(QEMUFile *f)
{
SaveStateEntry *se;
int ret = 1;
TAILQ_FOREACH(se, &savevm_handlers, entry) {
if (se->save_live_state == NULL)
continue;
/* Section type */
qemu_put_byte(f, QEMU_VM_SECTION_PART);
qemu_put_be32(f, se->secti... | false | qemu | 72cf2d4f0e181d0d3a3122e04129c58a95da713e |
3,649 | static void qmp_cleanup(void *datap)
{
QmpSerializeData *d = datap;
visit_free(qmp_output_get_visitor(d->qov));
visit_free(d->qiv);
g_free(d);
}
| false | qemu | 3b098d56979d2f7fd707c5be85555d114353a28d |
3,650 | void parse_numa_opts(MachineClass *mc)
{
int i;
if (qemu_opts_foreach(qemu_find_opts("numa"), parse_numa, NULL, NULL)) {
exit(1);
}
assert(max_numa_nodeid <= MAX_NODES);
/* No support for sparse NUMA node IDs yet: */
for (i = max_numa_nodeid - 1; i >= 0; i--) {
/* ... | false | qemu | cdda2018e3b9ce0c18938767dfdb1e05a05b67ca |
3,651 | static inline uint8_t *bt_hci_event_start(struct bt_hci_s *hci,
int evt, int len)
{
uint8_t *packet, mask;
int mask_byte;
if (len > 255) {
fprintf(stderr, "%s: HCI event params too long (%ib)\n",
__FUNCTION__, len);
exit(-1);
}
ma... | false | qemu | a89f364ae8740dfc31b321eed9ee454e996dc3c1 |
3,652 | uint64_t helper_efdctsidz (uint64_t val)
{
CPU_DoubleU u;
u.ll = val;
/* NaN are not treated the same way IEEE 754 does */
if (unlikely(float64_is_nan(u.d)))
return 0;
return float64_to_int64_round_to_zero(u.d, &env->vec_status);
}
| false | qemu | 185698715dfb18c82ad2a5dbc169908602d43e81 |
3,653 | static int kvm_has_msr_star(CPUState *env)
{
kvm_supported_msrs(env);
return has_msr_star;
}
| false | qemu | c3a3a7d356c4df2fe145037172ae52cba5f545a5 |
3,654 | int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
{
if (whence == SEEK_SET) {
/* nothing to do */
} else if (whence == SEEK_CUR) {
pos += qemu_ftell(f);
} else {
/* SEEK_END not supported */
return -1;
}
if (f->is_writable) {
qemu_fflush(f);
... | false | qemu | 5dafc53f1fb091d242f2179ffcb43bb28af36d1e |
3,655 | static void qbus_list_dev(BusState *bus, char *dest, int len)
{
DeviceState *dev;
const char *sep = " ";
int pos = 0;
pos += snprintf(dest+pos, len-pos, "devices at \"%s\":",
bus->name);
LIST_FOREACH(dev, &bus->children, sibling) {
pos += snprintf(dest+pos, len-... | false | qemu | 72cf2d4f0e181d0d3a3122e04129c58a95da713e |
3,656 | void vnc_zlib_zfree(void *x, void *addr)
{
qemu_free(addr);
}
| false | qemu | 245f7b51c0ea04fb2224b1127430a096c91aee70 |
3,657 | static target_ulong h_put_term_char(CPUState *env, sPAPREnvironment *spapr,
target_ulong opcode, target_ulong *args)
{
target_ulong reg = args[0];
target_ulong len = args[1];
target_ulong char0_7 = args[2];
target_ulong char8_15 = args[3];
VIOsPAPRDevice *s... | false | qemu | 3feef8ad17af7307373b9e88b9d7ecb98eeb99da |
3,659 | static void thread_pool_co_cb(void *opaque, int ret)
{
ThreadPoolCo *co = opaque;
co->ret = ret;
qemu_coroutine_enter(co->co);
}
| false | qemu | c2b38b277a7882a592f4f2ec955084b2b756daaa |
3,660 | static int qemu_balloon(ram_addr_t target)
{
if (!balloon_event_fn) {
return 0;
}
trace_balloon_event(balloon_opaque, target);
balloon_event_fn(balloon_opaque, target);
return 1;
}
| false | qemu | 6502a14734e71b2f6dd079b0a1e546e6aa2d2f8d |
3,661 | static bool cmd_write_dma(IDEState *s, uint8_t cmd)
{
bool lba48 = (cmd == WIN_WRITEDMA_EXT);
if (!s->bs) {
ide_abort_command(s);
return true;
}
ide_cmd_lba48_transform(s, lba48);
ide_sector_start_dma(s, IDE_DMA_WRITE);
s->media_changed = 1;
return false;
}... | false | qemu | 4be746345f13e99e468c60acbd3a355e8183e3ce |
3,663 | static uint64_t pxa2xx_pm_read(void *opaque, hwaddr addr,
unsigned size)
{
PXA2xxState *s = (PXA2xxState *) opaque;
switch (addr) {
case PMCR ... PCMD31:
if (addr & 3)
goto fail;
return s->pm_regs[addr >> 2];
default:
fail:
... | false | qemu | a89f364ae8740dfc31b321eed9ee454e996dc3c1 |
3,664 | static void ics_base_realize(DeviceState *dev, Error **errp)
{
ICSStateClass *icsc = ICS_BASE_GET_CLASS(dev);
ICSState *ics = ICS_BASE(dev);
Object *obj;
Error *err = NULL;
obj = object_property_get_link(OBJECT(dev), ICS_PROP_XICS, &err);
if (!obj) {
error_setg(errp, "%s: requi... | false | qemu | 100f738850639a108d6767316ce4dcc1d1ea4ae4 |
3,665 | bool postcopy_ram_supported_by_host(void)
{
error_report("%s: No OS support", __func__);
return false;
}
| false | qemu | d7651f150d61936344c4fab45eaeb0716c606af2 |
3,666 | int64_t qemu_file_get_rate_limit(QEMUFile *f)
{
return f->xfer_limit;
}
| true | qemu | 60fe637bf0e4d7989e21e50f52526444765c63b4 |
3,667 | static inline void put_codeword(PutBitContext *pb, vorbis_enc_codebook *cb,
int entry)
{
assert(entry >= 0);
assert(entry < cb->nentries);
assert(cb->lens[entry]);
put_bits(pb, cb->lens[entry], cb->codewords[entry]);
}
| true | FFmpeg | 1ba08c94f5bb4d1c3c2d3651b5e01edb4ce172e2 |
3,668 | static inline int qemu_rdma_buffer_mergable(RDMAContext *rdma,
uint64_t offset, uint64_t len)
{
RDMALocalBlock *block;
uint8_t *host_addr;
uint8_t *chunk_end;
if (rdma->current_index < 0) {
return 0;
}
if (rdma->current_chunk < 0) {
return 0;
... | true | qemu | 60fe637bf0e4d7989e21e50f52526444765c63b4 |
3,669 | static int vmdk_open_desc_file(BlockDriverState *bs, int flags,
int64_t desc_offset)
{
int ret;
char buf[2048];
char ct[128];
BDRVVmdkState *s = bs->opaque;
ret = bdrv_pread(bs->file, desc_offset, buf, sizeof(buf));
if (ret < 0) {
return ret;
... | true | qemu | b3c0bfb6f949d8f1c97f390f951c0bab3e703810 |
3,670 | static void vc1_mc_4mv_chroma(VC1Context *v, int dir)
{
MpegEncContext *s = &v->s;
H264ChromaContext *h264chroma = &v->h264chroma;
uint8_t *srcU, *srcV;
int uvmx, uvmy, uvsrc_x, uvsrc_y;
int k, tx = 0, ty = 0;
int mvx[4], mvy[4], intra[4], mv_f[4];
int valid_count;
int chroma_re... | true | FFmpeg | f6774f905fb3cfdc319523ac640be30b14c1bc55 |
3,671 | void palette8torgb24(const uint8_t *src, uint8_t *dst, unsigned num_pixels, const uint8_t *palette)
{
unsigned i;
/*
writes 1 byte o much and might cause alignment issues on some architectures?
for(i=0; i<num_pixels; i++)
((unsigned *)(&dst[i*3])) = ((unsigned *)palette)[ src[i] ];
*/
for(i=0; i<num_pixel... | true | FFmpeg | 7f526efd17973ec6d2204f7a47b6923e2be31363 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.