static int avi_write_packet(AVFormatContext *s, AVPacket *pkt) { AVIContext *avi = s->priv_data; ByteIOContext *pb = s->pb; unsigned char tag[5]; unsigned int flags=0; const int stream_index= pkt->stream_index; AVCodecContext *enc= s->streams[stream_index]->codec; int size= pkt->size; // av_log(s, AV_LOG_DEBUG, "%"PRId64" %d %d\n", pkt->dts, avi->packet_count[stream_index], stream_index); while(enc->block_align==0 && pkt->dts != AV_NOPTS_VALUE && pkt->dts > avi->packet_count[stream_index]){ AVPacket empty_packet; av_init_packet(&empty_packet); empty_packet.size= 0; empty_packet.data= NULL; empty_packet.stream_index= stream_index; avi_write_packet(s, &empty_packet); // av_log(s, AV_LOG_DEBUG, "dup %"PRId64" %d\n", pkt->dts, avi->packet_count[stream_index]); } avi->packet_count[stream_index]++; // Make sure to put an OpenDML chunk when the file size exceeds the limits if (!url_is_streamed(pb) && (url_ftell(pb) - avi->riff_start > AVI_MAX_RIFF_SIZE)) { avi_write_ix(s); end_tag(pb, avi->movi_list); if (avi->riff_id == 1) avi_write_idx1(s); end_tag(pb, avi->riff_start); avi->movi_list = avi_start_new_riff(avi, pb, "AVIX", "movi"); } avi_stream2fourcc(&tag[0], stream_index, enc->codec_type); if(pkt->flags&PKT_FLAG_KEY) flags = 0x10; if (enc->codec_type == CODEC_TYPE_AUDIO) { avi->audio_strm_length[stream_index] += size; } if (!url_is_streamed(s->pb)) { AVIIndex* idx = &avi->indexes[stream_index]; int cl = idx->entry / AVI_INDEX_CLUSTER_SIZE; int id = idx->entry % AVI_INDEX_CLUSTER_SIZE; if (idx->ents_allocated <= idx->entry) { idx->cluster = av_realloc(idx->cluster, (cl+1)*sizeof(void*)); if (!idx->cluster) return -1; idx->cluster[cl] = av_malloc(AVI_INDEX_CLUSTER_SIZE*sizeof(AVIIentry)); if (!idx->cluster[cl]) return -1; idx->ents_allocated += AVI_INDEX_CLUSTER_SIZE; } idx->cluster[cl][id].flags = flags; idx->cluster[cl][id].pos = url_ftell(pb) - avi->movi_list; idx->cluster[cl][id].len = size; idx->entry++; } put_buffer(pb, tag, 4); put_le32(pb, size); put_buffer(pb, pkt->data, size); if (size & 1) put_byte(pb, 0); put_flush_packet(pb); return 0; }
/* write the header (used two times if non streamed) */ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data_chunk_size) { ASFContext *asf = s->priv_data; ByteIOContext *pb = s->pb; AVMetadataTag *title, *author, *copyright, *comment; int header_size, n, extra_size, extra_size2, wav_extra_size, file_time; int has_title; int metadata_count; AVCodecContext *enc; int64_t header_offset, cur_pos, hpos; int bit_rate; int64_t duration; title = av_metadata_get(s->metadata, "title" , NULL, 0); author = av_metadata_get(s->metadata, "author" , NULL, 0); copyright = av_metadata_get(s->metadata, "copyright", NULL, 0); comment = av_metadata_get(s->metadata, "comment" , NULL, 0); duration = asf->duration + PREROLL_TIME * 10000; has_title = title || author || copyright || comment; metadata_count = s->metadata ? s->metadata->count : 0; bit_rate = 0; for(n=0;n<s->nb_streams;n++) { enc = s->streams[n]->codec; av_set_pts_info(s->streams[n], 32, 1, 1000); /* 32 bit pts in ms */ bit_rate += enc->bit_rate; } if (asf->is_streamed) { put_chunk(s, 0x4824, 0, 0xc00); /* start of stream (length will be patched later) */ } put_guid(pb, &ff_asf_header); put_le64(pb, -1); /* header length, will be patched after */ put_le32(pb, 3 + has_title + !!metadata_count + s->nb_streams); /* number of chunks in header */ put_byte(pb, 1); /* ??? */ put_byte(pb, 2); /* ??? */ /* file header */ header_offset = url_ftell(pb); hpos = put_header(pb, &ff_asf_file_header); put_guid(pb, &ff_asf_my_guid); put_le64(pb, file_size); file_time = 0; put_le64(pb, unix_to_file_time(file_time)); put_le64(pb, asf->nb_packets); /* number of packets */ put_le64(pb, duration); /* end time stamp (in 100ns units) */ put_le64(pb, asf->duration); /* duration (in 100ns units) */ put_le64(pb, PREROLL_TIME); /* start time stamp */ put_le32(pb, (asf->is_streamed || url_is_streamed(pb)) ? 3 : 2); /* ??? */ put_le32(pb, asf->packet_size); /* packet size */ put_le32(pb, asf->packet_size); /* packet size */ put_le32(pb, bit_rate); /* Nominal data rate in bps */ end_header(pb, hpos); /* unknown headers */ hpos = put_header(pb, &ff_asf_head1_guid); put_guid(pb, &ff_asf_head2_guid); put_le32(pb, 6); put_le16(pb, 0); end_header(pb, hpos); /* title and other infos */ if (has_title) { hpos = put_header(pb, &ff_asf_comment_header); put_le16(pb, title ? 2 * (strlen(title->value ) + 1) : 0); put_le16(pb, author ? 2 * (strlen(author->value ) + 1) : 0); put_le16(pb, copyright ? 2 * (strlen(copyright->value) + 1) : 0); put_le16(pb, comment ? 2 * (strlen(comment->value ) + 1) : 0); put_le16(pb, 0); if (title ) put_str16_nolen(pb, title->value ); if (author ) put_str16_nolen(pb, author->value ); if (copyright) put_str16_nolen(pb, copyright->value); if (comment ) put_str16_nolen(pb, comment->value ); end_header(pb, hpos); } if (metadata_count) { AVMetadataTag *tag = NULL; hpos = put_header(pb, &ff_asf_extended_content_header); put_le16(pb, metadata_count); while ((tag = av_metadata_get(s->metadata, "", tag, AV_METADATA_IGNORE_SUFFIX))) { put_le16(pb, 2*(strlen(tag->key) + 3) + 1); put_le16(pb, 'W'); put_le16(pb, 'M'); put_le16(pb, '/'); put_str16_nolen(pb, tag->key); put_le16(pb, 0); put_le16(pb, 2*strlen(tag->value) + 1); put_str16_nolen(pb, tag->value); } end_header(pb, hpos); } /* stream headers */ for(n=0;n<s->nb_streams;n++) { int64_t es_pos; // ASFStream *stream = &asf->streams[n]; enc = s->streams[n]->codec; asf->streams[n].num = n + 1; asf->streams[n].seq = 0; switch(enc->codec_type) { case CODEC_TYPE_AUDIO: wav_extra_size = 0; extra_size = 18 + wav_extra_size; extra_size2 = 8; break; default: case CODEC_TYPE_VIDEO: wav_extra_size = enc->extradata_size; extra_size = 0x33 + wav_extra_size; extra_size2 = 0; break; } hpos = put_header(pb, &ff_asf_stream_header); if (enc->codec_type == CODEC_TYPE_AUDIO) { put_guid(pb, &ff_asf_audio_stream); put_guid(pb, &ff_asf_audio_conceal_spread); } else { put_guid(pb, &ff_asf_video_stream); put_guid(pb, &ff_asf_video_conceal_none); } put_le64(pb, 0); /* ??? */ es_pos = url_ftell(pb); put_le32(pb, extra_size); /* wav header len */ put_le32(pb, extra_size2); /* additional data len */ put_le16(pb, n + 1); /* stream number */ put_le32(pb, 0); /* ??? */ if (enc->codec_type == CODEC_TYPE_AUDIO) { /* WAVEFORMATEX header */ int wavsize = put_wav_header(pb, enc); if ((enc->codec_id != CODEC_ID_MP3) && (enc->codec_id != CODEC_ID_MP2) && (enc->codec_id != CODEC_ID_ADPCM_IMA_WAV) && (enc->extradata_size==0)) { wavsize += 2; put_le16(pb, 0); } if (wavsize < 0) return -1; if (wavsize != extra_size) { cur_pos = url_ftell(pb); url_fseek(pb, es_pos, SEEK_SET); put_le32(pb, wavsize); /* wav header len */ url_fseek(pb, cur_pos, SEEK_SET); } /* ERROR Correction */ put_byte(pb, 0x01); if(enc->codec_id == CODEC_ID_ADPCM_G726 || !enc->block_align){ put_le16(pb, 0x0190); put_le16(pb, 0x0190); }else{ put_le16(pb, enc->block_align); put_le16(pb, enc->block_align); } put_le16(pb, 0x01); put_byte(pb, 0x00); } else { put_le32(pb, enc->width); put_le32(pb, enc->height); put_byte(pb, 2); /* ??? */ put_le16(pb, 40 + enc->extradata_size); /* size */ /* BITMAPINFOHEADER header */ put_bmp_header(pb, enc, codec_bmp_tags, 1); } end_header(pb, hpos); } /* media comments */ hpos = put_header(pb, &ff_asf_codec_comment_header); put_guid(pb, &ff_asf_codec_comment1_header); put_le32(pb, s->nb_streams); for(n=0;n<s->nb_streams;n++) { AVCodec *p; enc = s->streams[n]->codec; p = avcodec_find_encoder(enc->codec_id); if(enc->codec_type == CODEC_TYPE_AUDIO) put_le16(pb, 2); else if(enc->codec_type == CODEC_TYPE_VIDEO) put_le16(pb, 1); else put_le16(pb, -1); if(enc->codec_id == CODEC_ID_WMAV2) put_str16(pb, "Windows Media Audio V8"); else put_str16(pb, p ? p->name : enc->codec_name); put_le16(pb, 0); /* no parameters */ /* id */ if (enc->codec_type == CODEC_TYPE_AUDIO) { put_le16(pb, 2); put_le16(pb, enc->codec_tag); } else { put_le16(pb, 4); put_le32(pb, enc->codec_tag); } if(!enc->codec_tag) return -1; } end_header(pb, hpos); /* patch the header size fields */ cur_pos = url_ftell(pb); header_size = cur_pos - header_offset; if (asf->is_streamed) { header_size += 8 + 30 + 50; url_fseek(pb, header_offset - 10 - 30, SEEK_SET); put_le16(pb, header_size); url_fseek(pb, header_offset - 2 - 30, SEEK_SET); put_le16(pb, header_size); header_size -= 8 + 30 + 50; } header_size += 24 + 6; url_fseek(pb, header_offset - 14, SEEK_SET); put_le64(pb, header_size); url_fseek(pb, cur_pos, SEEK_SET); /* movie chunk, followed by packets of packet_size */ asf->data_offset = cur_pos; put_guid(pb, &ff_asf_data_header); put_le64(pb, data_chunk_size); put_guid(pb, &ff_asf_my_guid); put_le64(pb, asf->nb_packets); /* nb packets */ put_byte(pb, 1); /* ??? */ put_byte(pb, 1); /* ??? */ return 0; }
static __attribute__((always_inline)) void patch_CXNCAS_3_0_2_1793_extra(void) { put_byte(0x1007893F, 0xEA); }
static int gxf_write_material_data_section(ByteIOContext *pb, GXFContext *ctx) { offset_t pos; const char *filename = strrchr(ctx->fc->filename, '/'); pos = url_ftell(pb); put_be16(pb, 0); /* size */ /* name */ if (filename) filename++; else filename = ctx->fc->filename; put_byte(pb, MAT_NAME); put_byte(pb, strlen(SERVER_PATH) + strlen(filename) + 1); put_tag(pb, SERVER_PATH); put_tag(pb, filename); put_byte(pb, 0); /* first field */ put_byte(pb, MAT_FIRST_FIELD); put_byte(pb, 4); put_be32(pb, 0); /* last field */ put_byte(pb, MAT_LAST_FIELD); put_byte(pb, 4); put_be32(pb, ctx->nb_frames); /* reserved */ put_byte(pb, MAT_MARK_IN); put_byte(pb, 4); put_be32(pb, 0); put_byte(pb, MAT_MARK_OUT); put_byte(pb, 4); put_be32(pb, ctx->nb_frames); /* estimated size */ put_byte(pb, MAT_SIZE); put_byte(pb, 4); put_be32(pb, url_fsize(pb) / 1024); return updateSize(pb, pos); }
static void put_amf_bool(ByteIOContext *pb, int b) { put_byte(pb, AMF_DATA_TYPE_BOOL); put_byte(pb, !!b); }
static int mmf_write_header(AVFormatContext *s) { MMFContext *mmf = s->priv_data; ByteIOContext *pb = &s->pb; offset_t pos; int rate; rate = mmf_rate_code(s->streams[0]->codec->sample_rate); if(rate < 0) { av_log(s, AV_LOG_ERROR, "Unsupported sample rate %d\n", s->streams[0]->codec->sample_rate); return -1; } put_tag(pb, "MMMD"); put_be32(pb, 0); pos = start_tag(pb, "CNTI"); put_byte(pb, 0); /* class */ put_byte(pb, 0); /* type */ put_byte(pb, 0); /* code type */ put_byte(pb, 0); /* status */ put_byte(pb, 0); /* counts */ put_tag(pb, "VN:libavcodec,"); /* metadata ("ST:songtitle,VN:version,...") */ end_tag_be(pb, pos); put_buffer(pb, "ATR\x00", 4); put_be32(pb, 0); mmf->atrpos = url_ftell(pb); put_byte(pb, 0); /* format type */ put_byte(pb, 0); /* sequence type */ put_byte(pb, (0 << 7) | (1 << 4) | rate); /* (channel << 7) | (format << 4) | rate */ put_byte(pb, 0); /* wave base bit */ put_byte(pb, 2); /* time base d */ put_byte(pb, 2); /* time base g */ put_tag(pb, "Atsq"); put_be32(pb, 16); mmf->atsqpos = url_ftell(pb); /* Will be filled on close */ put_buffer(pb, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 16); mmf->awapos = start_tag(pb, "Awa\x01"); av_set_pts_info(s->streams[0], 64, 1, s->streams[0]->codec->sample_rate); put_flush_packet(pb); return 0; }
static void gxf_write_padding(ByteIOContext *pb, offset_t to_pad) { for (; to_pad > 0; to_pad--) { put_byte(pb, 0); } }
static uae_u32 REGPARAM2 dev_beginio (TrapContext *context) { uae_u32 request = m68k_areg (regs, 1); uae_u8 flags = get_byte (request + 30); int command = get_word (request + 28); struct priv_s2devstruct *pdev = getps2devstruct (request); struct s2devstruct *dev; put_byte (request + 8, NT_MESSAGE); if (!pdev) { write_log (_T("%s unknown iorequest (1) %08x\n"), getdevname (), request); put_byte (request + 31, 32); return get_byte (request + 31); } dev = gets2devstruct (pdev->unit); if (!dev) { write_log (_T("%s unknown iorequest (2) %08x\n"), getdevname (), request); put_byte (request + 31, 32); return get_byte (request + 31); } put_byte (request + 31, 0); if ((flags & 1) && dev_canquick (dev, request)) { if (dev_do_io (dev, request, 1)) write_log (_T("%s: command %d bug with IO_QUICK\n"), SANA2NAME, command); return get_byte (request + 31); } else { if (command == CMD_WRITE || command == S2_BROADCAST || command == S2_MULTICAST) { struct s2packet *s2p; if (!pdev->copyfrombuff || !pdev->copytobuff) { put_long (request + 32, S2ERR_BAD_ARGUMENT); put_byte (request + 31, S2WERR_BUFF_ERROR); } else { if (command == S2_BROADCAST) { uaecptr dstaddr = request + 32 + 4 + 4 + SANA2_MAX_ADDR_BYTES; put_byte (dstaddr + 0, 0xff); put_byte (dstaddr + 1, 0xff); put_byte (dstaddr + 2, 0xff); put_byte (dstaddr + 3, 0xff); put_byte (dstaddr + 4, 0xff); put_byte (dstaddr + 5, 0xff); } s2p = createwritepacket (context, request); if (s2p) { uae_sem_wait (&async_sem); add_async_packet (dev, s2p, request); uae_sem_post (&async_sem); } if (!s2p) { put_long (request + 32, S2WERR_BUFF_ERROR); put_byte (request + 31, S2ERR_NO_RESOURCES); } } } put_byte (request + 30, get_byte (request + 30) & ~1); write_comm_pipe_u32 (&dev->requests, request, 1); return 0; } }
static uae_u32 REGPARAM2 dev_open_2 (TrapContext *context) { uaecptr ioreq = m68k_areg (regs, 1); uae_u32 unit = m68k_dreg (regs, 0); uae_u32 flags = m68k_dreg (regs, 1); uaecptr buffermgmt; struct s2devstruct *dev = gets2devstruct (unit); struct priv_s2devstruct *pdev = 0; int i; uaecptr tagp, tagpnext; if (!dev) return openfail (ioreq, IOERR_OPENFAIL); if (!initint(context)) return openfail (ioreq, IOERR_SELFTEST); if (log_net) write_log (_T("opening %s:%d opencnt=%d ioreq=%08X\n"), SANA2NAME, unit, dev->opencnt, ioreq); if (get_word (ioreq + 0x12) < IOSTDREQ_SIZE) return openfail (ioreq, IOERR_BADLENGTH); if ((flags & SANA2OPF_PROM) && dev->opencnt > 0) return openfail (ioreq, IOERR_UNITBUSY); for (i = 0; i < MAX_OPEN_DEVICES; i++) { pdev = &pdevst[i]; if (pdev->inuse == 0) break; } if (i == MAX_OPEN_DEVICES) return openfail (ioreq, IOERR_UNITBUSY); put_long (ioreq + 24, pdev - pdevst); pdev->unit = unit; pdev->flags = flags; pdev->inuse = 1; pdev->td = td ? td[unit] : NULL; pdev->promiscuous = (flags & SANA2OPF_PROM) ? 1 : 0; if (pdev->td == NULL || pdev->td->active == 0) return openfail (ioreq, IOERR_OPENFAIL); if (dev->opencnt == 0) { dev->unit = unit; dev->sysdata = xcalloc (uae_u8, ethernet_getdatalenght (pdev->td)); if (!ethernet_open (pdev->td, dev->sysdata, dev, uaenet_gotdata, uaenet_getdata, pdev->promiscuous)) { xfree (dev->sysdata); dev->sysdata = NULL; return openfail (ioreq, IOERR_OPENFAIL); } write_log (_T("%s: initializing unit %d\n"), getdevname (), unit); dev->td = pdev->td; dev->adapter = pdev->td ? pdev->td->active : 0; if (dev->adapter) { dev->online = 1; dev->configured = 1; } start_thread (dev); } if (kickstart_version >= 36) { m68k_areg (regs, 0) = get_long (4) + 350; m68k_areg (regs, 1) = timerdevname; CallLib (context, get_long (4), -0x114); /* FindName('timer.device') */ pdev->timerbase = m68k_dreg (regs, 0); } pdev->copyfrombuff = pdev->copytobuff = pdev->packetfilter = 0; pdev->tempbuf = 0; if (get_word (ioreq + 0x12) >= SANA2_IOREQSIZE) { buffermgmt = get_long (ioreq + 32 + 4 + 4 + SANA2_MAX_ADDR_BYTES * 2 + 4 + 4 + 4); tagpnext = buffermgmt; while (tagpnext) { uae_u32 tag = get_long (tagpnext); uae_u32 val = get_long (tagpnext + 4); tagp = tagpnext; tagpnext += 8; switch (tag) { case TAG_DONE: tagpnext = 0; break; case TAG_IGNORE: break; case TAG_MORE: tagpnext = val; break; case TAG_SKIP: tagpnext = tagp + val * 8; break; case S2_CopyToBuff: pdev->copytobuff = val; break; case S2_CopyFromBuff: pdev->copyfrombuff = val; break; case S2_PacketFilter: pdev->packetfilter = val; break; } } if (log_net) write_log (_T("%s:%d CTB=%08x CFB=%08x PF=%08x\n"), getdevname(), unit, pdev->copytobuff, pdev->copyfrombuff, pdev->packetfilter); m68k_dreg (regs, 0) = dev->td->mtu + ETH_HEADER_SIZE + 2; m68k_dreg (regs, 1) = 1; pdev->tempbuf = CallLib (context, get_long (4), -0xC6); /* AllocMem */ if (!pdev->tempbuf) { if (dev->opencnt == 0) { ethernet_close (pdev->td, dev->sysdata); xfree (dev->sysdata); dev->sysdata = NULL; } return openfail (ioreq, S2ERR_BAD_ARGUMENT); } /* buffermanagement */ put_long (ioreq + 32 + 4 + 4 + SANA2_MAX_ADDR_BYTES * 2 + 4 + 4 + 4, pdev->tempbuf); } dev->exclusive = flags & SANA2OPF_MINE; dev->opencnt++; put_word (m68k_areg (regs, 6) + 32, get_word (m68k_areg (regs, 6) + 32) + 1); put_byte (ioreq + 31, 0); put_byte (ioreq + 8, 7); return 0; }
/* This is a bit more fancy that need be so that it syncs even in nasty cases. I'be been unable to make it reliably sync up with the change baudrate open command. It likes to sit and say it's been reset, with no more action. So I took all that code out. I'd rather sync reliably at 9600 than wait forever for a possible 19200 connection. */ static void rdp_init (int cold, int tty) { int sync = 0; int type = cold ? RDP_OPEN_TYPE_COLD : RDP_OPEN_TYPE_WARM; int baudtry = 9600; time_t now = time (0); time_t stop_time = now + 10; /* Try and sync for 10 seconds, then give up */ while (time (0) < stop_time && !sync) { int restype; QUIT; serial_flush_input (io); serial_flush_output (io); if (tty) printf_unfiltered ("Trying to connect at %d baud.\n", baudtry); /* ** It seems necessary to reset an EmbeddedICE to get it going. ** This has the side benefit of displaying the startup banner. */ if (cold) { put_byte (RDP_RESET); while ((restype = serial_readchar (io, 1)) > 0) { switch (restype) { case SERIAL_TIMEOUT: break; case RDP_RESET: /* Sent at start of reset process: ignore */ break; default: printf_unfiltered ("%c", isgraph (restype) ? restype : ' '); break; } } if (restype == 0) { /* Got end-of-banner mark */ printf_filtered ("\n"); } } put_byte (RDP_OPEN); put_byte (type | RDP_OPEN_TYPE_RETURN_SEX); put_word (0); while (!sync && (restype = serial_readchar (io, 1)) > 0) { if (remote_debug) fprintf_unfiltered (gdb_stdlog, "[%02x]\n", restype); switch (restype) { case SERIAL_TIMEOUT: break; case RDP_RESET: while ((restype = serial_readchar (io, 1)) == RDP_RESET) ; do { printf_unfiltered ("%c", isgraph (restype) ? restype : ' '); } while ((restype = serial_readchar (io, 1)) > 0); if (tty) { printf_unfiltered ("\nThe board has sent notification that it was reset.\n"); printf_unfiltered ("Waiting for it to settle down...\n"); } sleep (3); if (tty) printf_unfiltered ("\nTrying again.\n"); cold = 0; break; default: break; case RDP_RES_VALUE: { int resval = serial_readchar (io, 1); if (remote_debug) fprintf_unfiltered (gdb_stdlog, "[%02x]\n", resval); switch (resval) { case SERIAL_TIMEOUT: break; case RDP_RES_VALUE_LITTLE_ENDIAN: #if 0 /* FIXME: cagney/2003-11-22: Ever since the ARM was multi-arched (in 2002-02-08), this assignment has had no effect. There needs to be some sort of check/decision based on the current architecture's byte-order vs the remote target's byte order. For the moment disable the assignment to keep things building. */ target_byte_order = BFD_ENDIAN_LITTLE; #endif sync = 1; break; case RDP_RES_VALUE_BIG_ENDIAN: #if 0 /* FIXME: cagney/2003-11-22: Ever since the ARM was multi-arched (in 2002-02-08), this assignment has had no effect. There needs to be some sort of check/decision based on the current architecture's byte-order vs the remote target's byte order. For the moment disable the assignment to keep things building. */ target_byte_order = BFD_ENDIAN_BIG; #endif sync = 1; break; default: break; } } } } } if (!sync) { error ("Couldn't reset the board, try pressing the reset button"); } }
static bool transform_iconqnx_ibmpc (RECODE_SUBTASK subtask) { int input_char; /* current character */ input_char = get_byte (subtask); while (true) switch (input_char) { case EOF: SUBTASK_RETURN (subtask); case ENDLINE: put_byte (DOS_CR, subtask); put_byte (DOS_LF, subtask); input_char = get_byte (subtask); break; case DOS_CR: input_char = get_byte (subtask); if (input_char == DOS_LF) RETURN_IF_NOGO (RECODE_AMBIGUOUS_OUTPUT, subtask); put_byte (DOS_CR, subtask); break; case ESCAPE: input_char = get_byte (subtask); switch (input_char) { case 'A': input_char = get_byte (subtask); switch (input_char) { case 'a': input_char = 133; break; case 'e': input_char = 138; break; case 'u': input_char = 151; break; default: RETURN_IF_NOGO (RECODE_INVALID_INPUT, subtask); put_byte (ESCAPE, subtask); put_byte ('A', subtask); if (input_char == EOF) SUBTASK_RETURN (subtask); } break; case 'B': input_char = get_byte (subtask); switch (input_char) { case 'e': input_char = 130; break; case 'E': input_char = 144; break; default: RETURN_IF_NOGO (RECODE_INVALID_INPUT, subtask); put_byte (ESCAPE, subtask); put_byte ('B', subtask); if (input_char == EOF) SUBTASK_RETURN (subtask); } break; case 'C': input_char = get_byte (subtask); switch (input_char) { case 'a': input_char = 131; break; case 'e': input_char = 136; break; case 'i': input_char = 140; break; case 'o': input_char = 147; break; case 'u': input_char = 150; break; default: RETURN_IF_NOGO (RECODE_INVALID_INPUT, subtask); put_byte (ESCAPE, subtask); put_byte ('C', subtask); if (input_char == EOF) SUBTASK_RETURN (subtask); } break; case 'H': input_char = get_byte (subtask); switch (input_char) { case 'e': input_char = 137; break; case 'i': input_char = 139; break; case 'u': input_char = 129; break; default: RETURN_IF_NOGO (RECODE_INVALID_INPUT, subtask); put_byte (ESCAPE, subtask); put_byte ('H', subtask); if (input_char == EOF) SUBTASK_RETURN (subtask); } break; case 'K': input_char = get_byte (subtask); switch (input_char) { case 'c': input_char = 135; break; case 'C': input_char = 128; break; default: RETURN_IF_NOGO (RECODE_INVALID_INPUT, subtask); put_byte (ESCAPE, subtask); put_byte ('K', subtask); if (input_char == EOF) SUBTASK_RETURN (subtask); } break; default: RETURN_IF_NOGO (RECODE_INVALID_INPUT, subtask); put_byte (ESCAPE, subtask); if (input_char == EOF) SUBTASK_RETURN (subtask); } /* Fall through. */ default: put_byte (input_char, subtask); input_char = get_byte (subtask); } }
static void scsidev_do_scsi (struct scsidevdata *sdd, uaecptr request) { SCSI *scgp = sdd->scgp; struct scg_cmd *scmd = scgp->scmd; uaecptr acmd = get_long (request + 40); uaecptr scsi_data = get_long (acmd + 0); uae_u32 scsi_len = get_long (acmd + 4); uaecptr scsi_cmd = get_long (acmd + 12); uae_u16 scsi_cmd_len = get_word (acmd + 16); uae_u8 scsi_flags = get_byte (acmd + 20); uaecptr scsi_sense = get_long (acmd + 22); uae_u16 scsi_sense_len = get_word (acmd + 26); int sactual = 0; addrbank *bank_data = &get_mem_bank (scsi_data); addrbank *bank_cmd = &get_mem_bank (scsi_cmd); /* do transfer directly to and from Amiga memory */ if (!bank_data || !bank_data->check (scsi_data, scsi_len) || !bank_cmd || !bank_cmd->check (scsi_cmd, scsi_cmd_len)) { put_byte (request + 31, (uae_u8)-5); /* IOERR_BADADDRESS */ return; } #ifdef SCSI_IS_NOT_THREAD_SAFE uae_sem_wait (&scgp_sem); #endif scmd->timeout = 80 * 60; /* the Amiga does not tell us how long the timeout shall be, so make it _very_ long (specified in seconds) */ scmd->addr = bank_data->xlateaddr (scsi_data); scmd->size = scsi_len; scmd->flags = ((scsi_flags & 1) ? SCG_RECV_DATA : 0) | SCG_DISRE_ENA; scmd->cdb_len = scsi_cmd_len; memcpy(&scmd->cdb, bank_cmd->xlateaddr (scsi_cmd), scsi_cmd_len); scmd->target = sdd->target; scmd->sense_len = (scsi_flags & 4) ? 4 : /* SCSIF_OLDAUTOSENSE */ (scsi_flags & 2) ? scsi_sense_len : /* SCSIF_AUTOSENSE */ -1; scmd->sense_count = 0; *(uae_u8 *)&scmd->scb = 0; #ifdef DEBUG_CDR /* please ignore this code - it can be used to debug raw CD-R writing... */ if (!(scsi_len % 2368)) { /* Structure for generating bytes 2353...2368 if writing in ultra raw mode */ typedef struct QDATAtag { BYTE ControlAdr; BCD Tno; BCD Point; BCD Min; BCD Sec; BCD Frame; BYTE Zero; BCD PMin; BCD PSec; BCD PFrame; WORD Crc; BYTE Reserved[3]; BYTE PChannel; } QDATA; int i = scsi_len / 2368; QDATA *data = (QDATA *)&((unsigned char *)scmd->addr)[2352]; for (; i > 0; i--, data = (QDATA *)&((unsigned char *)data)[2368]) { printf ("$%02x: $%02x $%02x | $%02x:$%02x:$%02x = %6ld | $%02x | $%02x:$%02x:$%02x = %6ld\n", (int)data->ControlAdr, (int)*(UBYTE *)&data->Tno, (int)*(UBYTE *)&data->Point, (int)*(UBYTE *)&data->Min, (int)*(UBYTE *)&data->Sec, (int)*(UBYTE *)&data->Frame, BCDTime2Block_Pointer (&data->Min) + 150, *(UBYTE *)&data->Zero, *(UBYTE *)&data->PMin, *(UBYTE *)&data->PSec, *(UBYTE *)&data->PFrame, BCDTime2Block_Pointer (&data->PMin)); } fflush (stdout); } #endif scgp->scsibus = sdd->bus; scgp->target = sdd->target; scgp->lun = sdd->lun; scgp->cmdname = "???"; scgp->curcmdname = "???"; /* replace MODE_SELECT/SENSE_6 if we access a ATAPI drive, otherwise send it now */ if (sdd->isatapi && (scmd->cdb.g0_cdb.cmd == MODE_SELECT_6 || scmd->cdb.g0_cdb.cmd == MODE_SENSE_6)) { uae_u8 buffer[256 + 2], *data = scmd->addr, *tmp; int len = 0, page_len, i; int do_it = 1; uae_u8 sp = scmd->cdb.g0_cdb.high_addr & 1; uae_u8 alloc_len = scmd->cdb.g0_cdb.count; uae_u8 pcf_page_code = scmd->cdb.g0_cdb.mid_addr; uae_u8 cmd = scmd->cdb.g0_cdb.cmd; memset (&scmd->cdb.g1_cdb, 0, sizeof(scmd->cdb.g1_cdb)); if (cmd == MODE_SELECT_6) { /* expand parameter list */ tmp = data; buffer[len++] = *tmp++; /* first byte, should be 0 */ buffer[len++] = 0; /* reserved */ buffer[len++] = *tmp++; /* medium type */ buffer[len++] = 0; *tmp++; /* ignore host application code */ for (i = 0; i < 4; i++) { buffer[len++] = 0; } if (*tmp) { /* skip block descriptor */ tmp += 8; } tmp++; page_len = scsi_len - (tmp - data); if (page_len > 0) { memcpy (&buffer[len], tmp, page_len); len += page_len; scmd->cdb.g1_cdb.cmd = MODE_SELECT_10; scmd->cdb.g1_cdb.lun = sdd->lun; scmd->cdb.g1_cdb.res = 1 << 3; /* PF bit */ scmd->cdb.g1_cdb.reladr = sp; scmd->cdb.g1_cdb.count[0] = len >> 8; scmd->cdb.g1_cdb.count[1] = len; } else {
static int dev_do_io (struct devstruct *dev, uaecptr request) { uae_u32 command; uae_u32 io_data = get_long (request + 40); // 0x28 uae_u32 io_length = get_long (request + 36); // 0x24 uae_u32 io_actual = get_long (request + 32); // 0x20 uae_u32 io_offset = get_long (request + 44); // 0x2c uae_u32 io_error = 0; int async = 0; struct device_info di; struct priv_devstruct *pdev = getpdevstruct (request); if (!pdev) return 0; command = get_word (request+28); switch (command) { case CMD_READ: io_error = command_read (pdev->mode, dev, io_data, io_offset, io_length, &io_actual); break; case CMD_WRITE: case CMD_FORMAT: io_error = 28; /* writeprotect */ break; case CMD_UPDATE: case CMD_CLEAR: case CMD_FLUSH: case CMD_MOTOR: case CMD_SEEK: io_actual = 0; break; case CMD_REMOVE: io_actual = 0; break; case CMD_CHANGENUM: io_actual = dev->changenum; break; case CMD_CHANGESTATE: io_actual = devinfo(pdev->mode, dev->unitnum, &di)->media_inserted ? 0 : 1; break; case CMD_PROTSTATUS: io_actual = devinfo(pdev->mode, dev->unitnum, &di)->write_protected ? -1 : 0; break; case CMD_GETDRIVETYPE: io_actual = dev->drivetype; break; case CMD_GETNUMTRACKS: io_actual = dev->di.cylinders; break; case CMD_ADDCHANGEINT: io_error = add_async_request (dev, request, ASYNC_REQUEST_CHANGEINT, io_data); if (!io_error) async = 1; break; case CMD_REMCHANGEINT: release_async_request (dev, request); break; case 28: /* HD_SCSICMD */ if (dev->allow_scsi && pdev->scsi) { uae_u32 sdd = get_long (request + 40); io_error = sys_command_scsi_direct (dev->unitnum, sdd); if (log_scsi) write_log ("scsidev: did io: sdd %p request %p error %d\n", sdd, request, get_byte (request + 31)); } break; default: io_error = -3; break; } put_long (request + 32, io_actual); put_byte (request + 31, io_error); io_log ("dev_io",request); return async; }
STATIC_INLINE void memcpyha (uae_u32 dst, const uae_u8 *src, int size) { while (size--) put_byte (dst++, *src++); }
// -------------------------------------------------------------------------------------- void Ajp13Socket::Respond(const HttpResponse& res) { char msg[8192]; msg[0] = 'A'; msg[1] = 'B'; m_res = res; // reply codes // 0x3 Send Body Chunk // 0x4 Send Headers // 0x5 End Response // 0x6 Get Body Chunk // 0x9 CPong Reply // check content length if (!m_res.ContentLength() && m_res.GetFile().size()) { // m_res.SetContentLength( m_res.GetFile().size() ); } // Send Headers { int ptr = 4; put_byte(msg, ptr, 0x04); // send headers put_integer(msg, ptr, m_res.HttpStatusCode() ); put_string(msg, ptr, m_res.HttpStatusMsg() ); put_integer(msg, ptr, (short)m_res.Headers().size() ); for (Utility::ncmap<std::string>::const_iterator it = m_res.Headers().begin(); it != m_res.Headers().end(); ++it) { Utility::ncmap<int>::const_iterator it2 = Init.ResponseHeader.find( it -> first ); if (it2 != Init.ResponseHeader.end()) { put_integer(msg, ptr, it2 -> second); } else { put_string(msg, ptr, it -> first); } put_string(msg, ptr, it -> second); } std::list<std::string> vec = m_res.CookieNames(); { for (std::list<std::string>::iterator it = vec.begin(); it != vec.end(); ++it) { Utility::ncmap<int>::const_iterator it2 = Init.ResponseHeader.find( "set-cookie" ); if (it2 != Init.ResponseHeader.end()) { put_integer(msg, ptr, it2 -> second); } else { put_string(msg, ptr, "set-cookie"); } put_string(msg, ptr, m_res.Cookie(*it) ); } } short len = htons( ptr - 4 ); memcpy( msg + 2, &len, 2 ); SendBuf( msg, ptr ); } // Send Body Chunk OnTransferLimit(); }
static int dev_do_io_2 (struct s2devstruct *dev, uaecptr request, int quick) { uae_u8 flags = get_byte (request + 30); uae_u32 command = get_word (request + 28); uae_u32 packettype = get_long (request + 32 + 4); uaecptr data = get_long (request + 32 + 4 + 4 + SANA2_MAX_ADDR_BYTES * 2 + 4); uae_u32 datalength = get_long (request + 32 + 4 + 4 + SANA2_MAX_ADDR_BYTES * 2); uaecptr srcaddr = request + 32 + 4 + 4; uaecptr dstaddr = request + 32 + 4 + 4 + SANA2_MAX_ADDR_BYTES; uaecptr statdata = get_long (request + 32 + 4 + 4 + SANA2_MAX_ADDR_BYTES * 2 + 4 + 4); uaecptr buffermgmt = get_long (request + 32 + 4 + 4 + SANA2_MAX_ADDR_BYTES * 2 + 4 + 4 + 4); uae_u32 io_error = 0; uae_u32 wire_error = 0; int i; int async = 0; struct priv_s2devstruct *pdev = getps2devstruct (request); if (log_net) write_log (_T("S2: C=%02d T=%04X S=%02X%02X%02X%02X%02X%02X D=%02X%02X%02X%02X%02X%02X L=%d D=%08X SD=%08X BM=%08X\n"), command, packettype, get_byte (srcaddr + 0), get_byte (srcaddr + 1), get_byte (srcaddr + 2), get_byte (srcaddr + 3), get_byte (srcaddr + 4), get_byte (srcaddr + 5), get_byte (dstaddr + 0), get_byte (dstaddr + 1), get_byte (dstaddr + 2), get_byte (dstaddr + 3), get_byte (dstaddr + 4), get_byte (dstaddr + 5), datalength, data, statdata, buffermgmt); if (command == CMD_READ || command == S2_READORPHAN || command == CMD_WRITE || command == S2_BROADCAST || command == S2_MULTICAST) { if (!pdev->copyfrombuff || !pdev->copytobuff) { io_error = S2ERR_BAD_ARGUMENT; wire_error = S2WERR_BUFF_ERROR; goto end; } } switch (command) { case CMD_READ: if (!dev->online) goto offline; async = 1; break; case S2_READORPHAN: if (!dev->online) goto offline; async = 1; break; case S2_BROADCAST: case CMD_WRITE: if (!dev->online) goto offline; if (!checksize (request, dev)) goto toobig; async = 1; break; case S2_MULTICAST: if (!dev->online) goto offline; if ((get_byte (dstaddr + 0) & 1) == 0) { io_error = S2ERR_BAD_ADDRESS; wire_error = S2WERR_BAD_MULTICAST; goto end; } if (!checksize (request, dev)) goto toobig; async = 1; break; case CMD_FLUSH: dev->flush_timeout_cnt = 0; dev->flush_timeout = FLUSH_TIMEOUT; if (log_net) write_log (_T("CMD_FLUSH started %08x\n"), request); uae_sem_wait (&async_sem); flush (pdev); uae_sem_post (&async_sem); async = 1; uaenet_vsync_requested++; break; case S2_ADDMULTICASTADDRESS: addmulticastaddresses (dev, amigaaddrto64 (srcaddr), 0); break; case S2_DELMULTICASTADDRESS: if (!delmulticastaddresses (dev, amigaaddrto64 (srcaddr), 0)) { io_error = S2ERR_BAD_STATE; wire_error = S2WERR_BAD_MULTICAST; } break; case S2_ADDMULTICASTADDRESSES: addmulticastaddresses (dev, amigaaddrto64 (srcaddr), amigaaddrto64 (dstaddr)); break; case S2_DELMULTICASTADDRESSES: if (!delmulticastaddresses (dev, amigaaddrto64 (srcaddr), amigaaddrto64 (dstaddr))) { io_error = S2ERR_BAD_STATE; wire_error = S2WERR_BAD_MULTICAST; } break; case S2_DEVICEQUERY: { int size = get_long (statdata); if (size > 30) size = 30; put_long (statdata + 4, size); if (size >= 12) put_long (statdata + 8, 0); if (size >= 16) put_long (statdata + 12, 0); if (size >= 18) put_word (statdata + 16, ADDR_SIZE * 8); if (size >= 22) put_long (statdata + 18, dev->td->mtu); if (size >= 26) put_long (statdata + 22, 10000000); if (size >= 30) put_long (statdata + 26, S2WireType_Ethernet); } break; case S2_GETTYPESTATS: if (pdev->trackcnt) { put_long (statdata + 0, pdev->packetssent); put_long (statdata + 4, pdev->packetsreceived); put_long (statdata + 8, pdev->bytessent); put_long (statdata + 12, pdev->bytesreceived); put_long (statdata + 16, pdev->packetsdropped); } else { io_error = S2ERR_BAD_STATE; wire_error = S2WERR_NOT_TRACKED; } break; case S2_GETGLOBALSTATS: put_long (statdata + 0, dev->packetsreceived); put_long (statdata + 4, dev->packetssent); put_long (statdata + 8, dev->baddata); put_long (statdata + 12, dev->overruns); put_long (statdata + 16, 0); put_long (statdata + 20, dev->unknowntypesreceived); put_long (statdata + 24, dev->reconfigurations); put_long (statdata + 28, dev->online_secs); put_long (statdata + 32, dev->online_micro); break; case S2_GETSPECIALSTATS: put_long (statdata + 1, 0); break; case S2_GETSTATIONADDRESS: for (i = 0; i < ADDR_SIZE; i++) { put_byte (srcaddr + i, dev->td->mac[i]); put_byte (dstaddr + i, dev->td->mac[i]); } break; case S2_CONFIGINTERFACE: if (dev->configured) { io_error = S2ERR_BAD_STATE; wire_error = S2WERR_IS_CONFIGURED; } else { dev->configured = TRUE; } break; case S2_ONLINE: if (!dev->configured) { io_error = S2ERR_BAD_STATE; wire_error = S2WERR_NOT_CONFIGURED; } if (!dev->adapter) { io_error = S2ERR_OUTOFSERVICE; wire_error = S2WERR_RCVREL_HDW_ERR; } if (!io_error) { uaenet_vsync_requested++; async = 1; } break; case S2_TRACKTYPE: if (packettype <= 65535) { if (pdev->tracks[packettype]) { io_error = S2ERR_BAD_STATE; wire_error = S2WERR_ALREADY_TRACKED; } else { pdev->tracks[packettype] = 1; pdev->trackcnt++; } } else { io_error = S2ERR_BAD_ARGUMENT; } break; case S2_UNTRACKTYPE: if (packettype <= 65535) { if (!pdev->tracks[packettype]) { io_error = S2ERR_BAD_STATE; wire_error = S2WERR_NOT_TRACKED; } else { pdev->tracks[packettype] = 0; pdev->trackcnt--; } } else { io_error = S2ERR_BAD_ARGUMENT; } break; case S2_OFFLINE: if (dev->online) { dev->online = 0; checkevents (dev, S2EVENT_OFFLINE, 1); } break; case S2_ONEVENT: { uae_u32 events; uae_u32 wanted_events = get_long (request + 32); if (wanted_events & ~KNOWN_EVENTS) { io_error = S2ERR_NOT_SUPPORTED; events = S2WERR_BAD_EVENT; } else { if (dev->online) events = S2EVENT_ONLINE; else events = S2EVENT_OFFLINE; events &= wanted_events; if (events) { wire_error = events; } else { async = 1; } } } break; default: io_error = IOERR_NOCMD; break; offline: io_error = S2ERR_OUTOFSERVICE; wire_error = S2WERR_UNIT_OFFLINE; break; toobig: io_error = S2ERR_MTU_EXCEEDED; wire_error = S2WERR_GENERIC_ERROR; break; } end: if (log_net && (io_error || wire_error)) write_log (_T("-> %d (%d)\n"), io_error, wire_error); put_long (request + 32, wire_error); put_byte (request + 31, io_error); return async; }
static int aiff_write_header(AVFormatContext *s) { AIFFOutputContext *aiff = s->priv_data; ByteIOContext *pb = &s->pb; AVCodecContext *enc = s->streams[0]->codec; AVExtFloat sample_rate; int coder_len; /* First verify if format is ok */ enc->codec_tag = codec_get_tag(codec_aiff_tags, enc->codec_id); if (!enc->codec_tag) { av_free(aiff); return -1; } coder_len = strlen(enc->codec->name); /* FORM AIFF header */ put_tag(pb, "FORM"); aiff->form = url_ftell(pb); put_be32(pb, 0); /* file length */ put_tag(pb, "AIFC"); /* Version chunk */ put_tag(pb, "FVER"); put_be32(pb, 4); put_be32(pb, 0xA2805140); /* Common chunk */ put_tag(pb, "COMM"); if (coder_len & 1) /* Common chunk is of var size */ put_be32(pb, 23+coder_len); else put_be32(pb, 24+coder_len); put_be16(pb, enc->channels); /* Number of channels */ aiff->frames = url_ftell(pb); put_be32(pb, 0); /* Number of frames */ if (!enc->bits_per_sample) enc->bits_per_sample = (enc->block_align<<3) / enc->channels; put_be16(pb, enc->bits_per_sample); /* Sample size */ sample_rate = av_dbl2ext((double)enc->sample_rate); put_buffer(pb, (uint8_t*)&sample_rate, sizeof(sample_rate)); put_le32(pb, enc->codec_tag); if (coder_len & 1) { put_byte(pb, coder_len); put_buffer(pb, (uint8_t*)enc->codec->name, coder_len); } else { put_byte(pb, coder_len+1); put_buffer(pb, (uint8_t*)enc->codec->name, coder_len); put_byte(pb, 0); } /* Sound data chunk */ put_tag(pb, "SSND"); aiff->ssnd = url_ftell(pb); /* Sound chunk size */ put_be32(pb, 0); /* Sound samples data size */ put_be32(pb, 0); /* Data offset */ put_be32(pb, 0); /* Block-size (block align) */ av_set_pts_info(s->streams[0], 64, 1, s->streams[0]->codec->sample_rate); /* Data is starting here */ put_flush_packet(pb); return 0; }
static int openfail (uaecptr ioreq, int error) { put_long (ioreq + 20, -1); put_byte (ioreq + 31, error); return (uae_u32)-1; }
/* * Hack -- add data to the current block */ static void put_char(char v) { put_byte((byte)(v)); }
void uaeser_signal (void *vdev, int sigmask) { struct devstruct *dev = (struct devstruct*)vdev; struct asyncreq *ar; int i = 0; uae_sem_wait (&async_sem); ar = dev->ar; while (ar) { if (!ar->ready) { uaecptr request = ar->request; uae_u32 io_data = get_long (request + 40); // 0x28 uae_u32 io_length = get_long (request + 36); // 0x24 int command = get_word (request + 28); uae_u32 io_error = 0, io_actual = 0; uae_u8 *addr; int io_done = 0; switch (command) { case SDCMD_BREAK: if (ar == dev->ar) { uaeser_break (dev->sysdata, get_long (request + io_BrkTime)); io_done = 1; } break; case CMD_READ: if (sigmask & 1) { addr = memmap(io_data, io_length); if (addr) { if (uaeser_read (dev->sysdata, addr, io_length)) { io_error = 0; io_actual = io_length; io_done = 1; } } else { io_error = IOERR_BADADDRESS; io_done = 1; } } break; case CMD_WRITE: if (sigmask & 2) { io_error = IOERR_BADADDRESS; addr = memmap(io_data, io_length); if (addr && uaeser_write (dev->sysdata, addr, io_length)) io_error = 0; io_actual = io_length; io_done = 1; } break; default: write_log (_T("%s:%d incorrect async request %x (cmd=%d) signaled?!"), getdevname(), dev->unit, request, command); break; } if (io_done) { if (log_uaeserial) write_log (_T("%s:%d async request %x completed\n"), getdevname(), dev->unit, request); put_long (request + 32, io_actual); put_byte (request + 31, io_error); ar->ready = 1; write_comm_pipe_u32 (&dev->requests, request, 1); } } ar = ar->next; } uae_sem_post (&async_sem); }
static int gxf_write_track_description(ByteIOContext *pb, GXFStreamContext *stream) { offset_t pos; /* track description section */ put_byte(pb, stream->media_type + 0x80); put_byte(pb, stream->index + 0xC0); pos = url_ftell(pb); put_be16(pb, 0); /* size */ /* media file name */ put_byte(pb, TRACK_NAME); put_byte(pb, strlen(ES_NAME_PATTERN) + 3); put_tag(pb, ES_NAME_PATTERN); put_be16(pb, stream->media_info); put_byte(pb, 0); if (stream->codec->codec_id != CODEC_ID_MPEG2VIDEO) { /* auxiliary information */ put_byte(pb, TRACK_AUX); put_byte(pb, 8); if (stream->codec->codec_id == CODEC_ID_NONE) gxf_write_timecode_auxiliary(pb, stream); else put_le64(pb, 0); } /* file system version */ put_byte(pb, TRACK_VER); put_byte(pb, 4); put_be32(pb, 0); if (stream->codec->codec_id == CODEC_ID_MPEG2VIDEO) gxf_write_mpeg_auxiliary(pb, stream); /* frame rate */ put_byte(pb, TRACK_FPS); put_byte(pb, 4); put_be32(pb, stream->frame_rate_index); /* lines per frame */ put_byte(pb, TRACK_LINES); put_byte(pb, 4); put_be32(pb, stream->lines_index); /* fields per frame */ put_byte(pb, TRACK_FPF); put_byte(pb, 4); put_be32(pb, stream->fields); return updateSize(pb, pos); }
static int dev_do_io (struct devstruct *dev, uaecptr request, int quick) { uae_u32 command; uae_u32 io_data = get_long (request + 40); // 0x28 uae_u32 io_length = get_long (request + 36); // 0x24 uae_u32 io_actual = get_long (request + 32); // 0x20 uae_u32 io_offset = get_long (request + 44); // 0x2c uae_u32 io_error = 0; uae_u16 io_status; int async = 0; if (!dev) return 0; command = get_word (request + 28); io_log (_T("dev_io_START"),request); switch (command) { case SDCMD_QUERY: if (uaeser_query (dev->sysdata, &io_status, &io_actual)) put_byte (request + io_Status, io_status); else io_error = IOERR_BADADDRESS; break; case SDCMD_SETPARAMS: io_error = setparams(dev, request); break; case CMD_WRITE: async = 1; break; case CMD_READ: async = 1; break; case SDCMD_BREAK: if (get_byte (request + io_SerFlags) & SERF_QUEUEDBRK) { async = 1; } else { uaeser_break (dev->sysdata, get_long (request + io_BrkTime)); } break; case CMD_CLEAR: uaeser_clearbuffers(dev->sysdata); break; case CMD_RESET: cmd_reset(dev, request); break; case CMD_FLUSH: case CMD_START: case CMD_STOP: break; case NSCMD_DEVICEQUERY: put_long (io_data + 0, 0); put_long (io_data + 4, 16); /* size */ put_word (io_data + 8, NSDEVTYPE_SERIAL); put_word (io_data + 10, 0); put_long (io_data + 12, nscmd_cmd); io_actual = 16; break; default: io_error = IOERR_NOCMD; break; } put_long (request + 32, io_actual); put_byte (request + 31, io_error); io_log (_T("dev_io_END"),request); return async; }
static void put_amf_double(ByteIOContext *pb, double d) { put_byte(pb, AMF_DATA_TYPE_NUMBER); put_be64(pb, av_dbl2int(d)); }
void RTMPSession::pushBuffer(const uint8_t* const data, size_t size, IMetadata& metadata) { if(m_ending) { return ; } std::shared_ptr<Buffer> buf = std::make_shared<Buffer>(size); buf->put(const_cast<uint8_t*>(data), size); const RTMPMetadata_t inMetadata = static_cast<const RTMPMetadata_t&>(metadata); m_jobQueue.enqueue([=]() { if(!this->m_ending) { static int c_count = 0; c_count ++; auto packetTime = std::chrono::steady_clock::now(); std::vector<uint8_t> chunk; std::shared_ptr<std::vector<uint8_t>> outb = std::make_shared<std::vector<uint8_t>>(); outb->reserve(size + 64); size_t len = buf->size(); size_t tosend = std::min(len, m_outChunkSize); uint8_t* p; buf->read(&p, buf->size()); uint64_t ts = inMetadata.getData<kRTMPMetadataTimestamp>() ; const int streamId = inMetadata.getData<kRTMPMetadataMsgStreamId>(); #ifndef RTMP_CHUNK_TYPE_0_ONLY auto it = m_previousChunkData.find(streamId); if(it == m_previousChunkData.end()) { #endif // Type 0. put_byte(chunk, ( streamId & 0x1F)); put_be24(chunk, static_cast<uint32_t>(ts)); put_be24(chunk, inMetadata.getData<kRTMPMetadataMsgLength>()); put_byte(chunk, inMetadata.getData<kRTMPMetadataMsgTypeId>()); put_buff(chunk, (uint8_t*)&m_streamId, sizeof(int32_t)); // msg stream id is little-endian #ifndef RTMP_CHUNK_TYPE_0_ONLY } else { // Type 1. put_byte(chunk, RTMP_CHUNK_TYPE_1 | (streamId & 0x1F)); put_be24(chunk, static_cast<uint32_t>(ts - it->second)); // timestamp delta put_be24(chunk, inMetadata.getData<kRTMPMetadataMsgLength>()); put_byte(chunk, inMetadata.getData<kRTMPMetadataMsgTypeId>()); } #endif m_previousChunkData[streamId] = ts; put_buff(chunk, p, tosend); outb->insert(outb->end(), chunk.begin(), chunk.end()); len -= tosend; p += tosend; while(len > 0) { tosend = std::min(len, m_outChunkSize); p[-1] = RTMP_CHUNK_TYPE_3 | (streamId & 0x1F); outb->insert(outb->end(), p-1, p+tosend); p+=tosend; len-=tosend; // this->write(&outb[0], outb.size(), packetTime); // outb.clear(); } this->write(&(*outb)[0], outb->size(), packetTime, inMetadata.getData<kRTMPMetadataIsKeyframe>() ); } }); }
static int flv_write_header(AVFormatContext *s) { ByteIOContext *pb = s->pb; FLVContext *flv = s->priv_data; int i, width, height, samplerate, samplesize, channels, audiocodecid, videocodecid; double framerate = 0.0; int metadata_size_pos, data_size; flv->hasAudio = 0; flv->hasVideo = 0; for(i=0; i<s->nb_streams; i++){ AVCodecContext *enc = s->streams[i]->codec; if (enc->codec_type == CODEC_TYPE_VIDEO) { width = enc->width; height = enc->height; if (s->streams[i]->r_frame_rate.den && s->streams[i]->r_frame_rate.num) { framerate = av_q2d(s->streams[i]->r_frame_rate); } else { framerate = 1/av_q2d(s->streams[i]->codec->time_base); } flv->hasVideo=1; videocodecid = enc->codec_tag; if(videocodecid == 0) { av_log(enc, AV_LOG_ERROR, "video codec not compatible with flv\n"); return -1; } } else { flv->hasAudio=1; samplerate = enc->sample_rate; channels = enc->channels; audiocodecid = enc->codec_tag; samplesize = (enc->codec_id == CODEC_ID_PCM_S8) ? 8 : 16; if(get_audio_flags(enc)<0) return -1; } av_set_pts_info(s->streams[i], 24, 1, 1000); /* 24 bit pts in ms */ } put_tag(pb,"FLV"); put_byte(pb,1); put_byte(pb, FLV_HEADER_FLAG_HASAUDIO * flv->hasAudio + FLV_HEADER_FLAG_HASVIDEO * flv->hasVideo); put_be32(pb,9); put_be32(pb,0); for(i=0; i<s->nb_streams; i++){ if(s->streams[i]->codec->codec_tag == 5){ put_byte(pb,8); // message type put_be24(pb,0); // include flags put_be24(pb,0); // time stamp put_be32(pb,0); // reserved put_be32(pb,11); // size flv->reserved=5; } } /* write meta_tag */ put_byte(pb, 18); // tag type META metadata_size_pos= url_ftell(pb); put_be24(pb, 0); // size of data part (sum of all parts below) put_be24(pb, 0); // time stamp put_be32(pb, 0); // reserved /* now data of data_size size */ /* first event name as a string */ put_byte(pb, AMF_DATA_TYPE_STRING); put_amf_string(pb, "onMetaData"); // 12 bytes /* mixed array (hash) with size and string/type/data tuples */ put_byte(pb, AMF_DATA_TYPE_MIXEDARRAY); put_be32(pb, 5*flv->hasVideo + 4*flv->hasAudio + 2); // +2 for duration and file size put_amf_string(pb, "duration"); flv->duration_offset= url_ftell(pb); put_amf_double(pb, 0); // delayed write if(flv->hasVideo){ put_amf_string(pb, "width"); put_amf_double(pb, width); put_amf_string(pb, "height"); put_amf_double(pb, height); put_amf_string(pb, "videodatarate"); put_amf_double(pb, s->bit_rate / 1024.0); put_amf_string(pb, "framerate"); put_amf_double(pb, framerate); put_amf_string(pb, "videocodecid"); put_amf_double(pb, videocodecid); } if(flv->hasAudio){ put_amf_string(pb, "audiosamplerate"); put_amf_double(pb, samplerate); put_amf_string(pb, "audiosamplesize"); put_amf_double(pb, samplesize); put_amf_string(pb, "stereo"); put_amf_bool(pb, (channels == 2)); put_amf_string(pb, "audiocodecid"); put_amf_double(pb, audiocodecid); } put_amf_string(pb, "filesize"); flv->filesize_offset= url_ftell(pb); put_amf_double(pb, 0); // delayed write put_amf_string(pb, ""); put_byte(pb, AMF_END_OF_OBJECT); /* write total size of tag */ data_size= url_ftell(pb) - metadata_size_pos - 10; url_fseek(pb, metadata_size_pos, SEEK_SET); put_be24(pb, data_size); url_fseek(pb, data_size + 10 - 3, SEEK_CUR); put_be32(pb, data_size + 11); return 0; }
void RTMPSession::sendHeaderPacket() { std::vector<uint8_t> outBuffer; std::vector<uint8_t> enc; RTMPChunk_0 metadata = {{0}}; put_string(enc, "@setDataFrame"); put_string(enc, "onMetaData"); put_byte(enc, kAMFObject); //put_be32(enc, 5+5+2); // videoEnabled + audioEnabled + 2 //put_named_double(enc, "duration", 0.0); put_named_double(enc, "width", m_frameWidth); put_named_double(enc, "height", m_frameHeight); put_named_double(enc, "displaywidth", m_frameWidth); put_named_double(enc, "displayheight", m_frameHeight); put_named_double(enc, "framewidth", m_frameWidth); put_named_double(enc, "frameheight", m_frameHeight); put_named_double(enc, "videodatarate", static_cast<double>(m_bitrate) / 1024.); put_named_double(enc, "videoframerate", 1. / m_frameDuration); put_named_string(enc, "videocodecid", "avc1"); { put_name(enc, "trackinfo"); put_byte(enc, kAMFStrictArray); put_be32(enc, 2); // // Audio stream metadata put_byte(enc, kAMFObject); put_named_string(enc, "type", "audio"); { std::stringstream ss; ss << "{AACFrame: codec:AAC, channels: " << m_audioStereo+1 << ", frequency:" << m_audioSampleRate << ", samplesPerFrame:1024, objectType:LC}"; put_named_string(enc, "description", ss.str()); } put_named_double(enc, "timescale", 1000.); put_name(enc, "sampledescription"); put_byte(enc, kAMFStrictArray); put_be32(enc, 1); put_byte(enc, kAMFObject); put_named_string(enc, "sampletype", "mpeg4-generic"); put_byte(enc, 0); put_byte(enc, 0); put_byte(enc, kAMFObjectEnd); put_named_string(enc, "language", "eng"); put_byte(enc, 0); put_byte(enc, 0); put_byte(enc, kAMFObjectEnd); // // Video stream metadata put_byte(enc, kAMFObject); put_named_string(enc, "type", "video"); put_named_double(enc, "timescale", 1000.); put_named_string(enc, "language", "eng"); put_name(enc, "sampledescription"); put_byte(enc, kAMFStrictArray); put_be32(enc, 1); put_byte(enc, kAMFObject); put_named_string(enc, "sampletype", "H264"); put_byte(enc, 0); put_byte(enc, 0); put_byte(enc, kAMFObjectEnd); put_byte(enc, 0); put_byte(enc, 0); put_byte(enc, kAMFObjectEnd); } put_be16(enc, 0); put_byte(enc, kAMFObjectEnd); put_named_double(enc, "audiodatarate", 131152. / 1024.); put_named_double(enc, "audiosamplerate", m_audioSampleRate); put_named_double(enc, "audiosamplesize", 16); put_named_double(enc, "audiochannels", m_audioStereo + 1); put_named_string(enc, "audiocodecid", "mp4a"); put_be16(enc, 0); put_byte(enc, kAMFObjectEnd); size_t len = enc.size(); put_buff(outBuffer, (uint8_t*)&enc[0], static_cast<size_t>(len)); metadata.msg_type_id = FLV_TAG_TYPE_META; metadata.msg_stream_id = kAudioChannelStreamId; metadata.msg_length.data = static_cast<int>( outBuffer.size() ); metadata.timestamp.data = 0; sendPacket(&outBuffer[0], outBuffer.size(), metadata); }
static __attribute__((always_inline)) void patch_CXCAS_3_0_1_1753_extra(void) { put_byte(0x100788C7, 0xEA); }
int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count) { ByteIOContext pb; uint8_t *buf; int len; int rtcp_bytes; RTPStatistics *stats= &s->statistics; uint32_t lost; uint32_t extended_max; uint32_t expected_interval; uint32_t received_interval; uint32_t lost_interval; uint32_t expected; uint32_t fraction; uint64_t ntp_time= s->last_rtcp_ntp_time; // TODO: Get local ntp time? if (!s->rtp_ctx || (count < 1)) return -1; /* TODO: I think this is way too often; RFC 1889 has algorithm for this */ /* XXX: mpeg pts hardcoded. RTCP send every 0.5 seconds */ s->octet_count += count; rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) / RTCP_TX_RATIO_DEN; rtcp_bytes /= 50; // mmu_man: that's enough for me... VLC sends much less btw !? if (rtcp_bytes < 28) return -1; s->last_octet_count = s->octet_count; if (url_open_dyn_buf(&pb) < 0) return -1; // Receiver Report put_byte(&pb, (RTP_VERSION << 6) + 1); /* 1 report block */ put_byte(&pb, 201); put_be16(&pb, 7); /* length in words - 1 */ put_be32(&pb, s->ssrc); // our own SSRC put_be32(&pb, s->ssrc); // XXX: should be the server's here! // some placeholders we should really fill... // RFC 1889/p64 extended_max= stats->cycles + stats->max_seq; expected= extended_max - stats->base_seq + 1; lost= expected - stats->received; lost= FFMIN(lost, 0xffffff); // clamp it since it's only 24 bits... expected_interval= expected - stats->expected_prior; stats->expected_prior= expected; received_interval= stats->received - stats->received_prior; stats->received_prior= stats->received; lost_interval= expected_interval - received_interval; if (expected_interval==0 || lost_interval<=0) fraction= 0; else fraction = (lost_interval<<8)/expected_interval; fraction= (fraction<<24) | lost; put_be32(&pb, fraction); /* 8 bits of fraction, 24 bits of total packets lost */ put_be32(&pb, extended_max); /* max sequence received */ put_be32(&pb, stats->jitter>>4); /* jitter */ if(s->last_rtcp_ntp_time==AV_NOPTS_VALUE) { put_be32(&pb, 0); /* last SR timestamp */ put_be32(&pb, 0); /* delay since last SR */ } else { uint32_t middle_32_bits= s->last_rtcp_ntp_time>>16; // this is valid, right? do we need to handle 64 bit values special? uint32_t delay_since_last= ntp_time - s->last_rtcp_ntp_time; put_be32(&pb, middle_32_bits); /* last SR timestamp */ put_be32(&pb, delay_since_last); /* delay since last SR */ } // CNAME put_byte(&pb, (RTP_VERSION << 6) + 1); /* 1 report block */ put_byte(&pb, 202); len = strlen(s->hostname); put_be16(&pb, (6 + len + 3) / 4); /* length in words - 1 */ put_be32(&pb, s->ssrc); put_byte(&pb, 0x01); put_byte(&pb, len); put_buffer(&pb, s->hostname, len); // padding for (len = (6 + len) % 4; len % 4; len++) { put_byte(&pb, 0); } put_flush_packet(&pb); len = url_close_dyn_buf(&pb, &buf); if ((len > 0) && buf) { int result; #if defined(DEBUG) printf("sending %d bytes of RR\n", len); #endif result= url_write(s->rtp_ctx, buf, len); #if defined(DEBUG) printf("result from url_write: %d\n", result); #endif av_free(buf); } return 0; }
static __attribute__((always_inline)) void patch_CXCAS_3_2_0_1219_extra(void) { #if OVERCLOCK put_word(0x10000258, NOP); #endif put_byte(0x10084273, 0xEA); }
static int avi_write_header(AVFormatContext *s) { AVIContext *avi = s->priv_data; ByteIOContext *pb = s->pb; int bitrate, n, i, nb_frames, au_byterate, au_ssize, au_scale; AVCodecContext *stream, *video_enc; offset_t list1, list2, strh, strf; /* header list */ avi->riff_id = 0; list1 = avi_start_new_riff(avi, pb, "AVI ", "hdrl"); /* avi header */ put_tag(pb, "avih"); put_le32(pb, 14 * 4); bitrate = 0; video_enc = NULL; for(n=0;n<s->nb_streams;n++) { stream = s->streams[n]->codec; bitrate += stream->bit_rate; if (stream->codec_type == CODEC_TYPE_VIDEO) video_enc = stream; } nb_frames = 0; if(video_enc){ put_le32(pb, (uint32_t)(INT64_C(1000000) * video_enc->time_base.num / video_enc->time_base.den)); } else { put_le32(pb, 0); } put_le32(pb, bitrate / 8); /* XXX: not quite exact */ put_le32(pb, 0); /* padding */ if (url_is_streamed(pb)) put_le32(pb, AVIF_TRUSTCKTYPE | AVIF_ISINTERLEAVED); /* flags */ else put_le32(pb, AVIF_TRUSTCKTYPE | AVIF_HASINDEX | AVIF_ISINTERLEAVED); /* flags */ avi->frames_hdr_all = url_ftell(pb); /* remember this offset to fill later */ put_le32(pb, nb_frames); /* nb frames, filled later */ put_le32(pb, 0); /* initial frame */ put_le32(pb, s->nb_streams); /* nb streams */ put_le32(pb, 1024 * 1024); /* suggested buffer size */ if(video_enc){ put_le32(pb, video_enc->width); put_le32(pb, video_enc->height); } else { put_le32(pb, 0); put_le32(pb, 0); } put_le32(pb, 0); /* reserved */ put_le32(pb, 0); /* reserved */ put_le32(pb, 0); /* reserved */ put_le32(pb, 0); /* reserved */ /* stream list */ for(i=0;i<n;i++) { list2 = start_tag(pb, "LIST"); put_tag(pb, "strl"); stream = s->streams[i]->codec; /* stream generic header */ strh = start_tag(pb, "strh"); switch(stream->codec_type) { case CODEC_TYPE_VIDEO: put_tag(pb, "vids"); break; case CODEC_TYPE_AUDIO: put_tag(pb, "auds"); break; // case CODEC_TYPE_TEXT : put_tag(pb, "txts"); break; case CODEC_TYPE_DATA : put_tag(pb, "dats"); break; } if(stream->codec_type == CODEC_TYPE_VIDEO) put_le32(pb, stream->codec_tag); else put_le32(pb, 1); put_le32(pb, 0); /* flags */ put_le16(pb, 0); /* priority */ put_le16(pb, 0); /* language */ put_le32(pb, 0); /* initial frame */ ff_parse_specific_params(stream, &au_byterate, &au_ssize, &au_scale); put_le32(pb, au_scale); /* scale */ put_le32(pb, au_byterate); /* rate */ av_set_pts_info(s->streams[i], 64, au_scale, au_byterate); put_le32(pb, 0); /* start */ avi->frames_hdr_strm[i] = url_ftell(pb); /* remember this offset to fill later */ if (url_is_streamed(pb)) put_le32(pb, AVI_MAX_RIFF_SIZE); /* FIXME: this may be broken, but who cares */ else put_le32(pb, 0); /* length, XXX: filled later */ /* suggested buffer size */ //FIXME set at the end to largest chunk if(stream->codec_type == CODEC_TYPE_VIDEO) put_le32(pb, 1024 * 1024); else if(stream->codec_type == CODEC_TYPE_AUDIO) put_le32(pb, 12 * 1024); else put_le32(pb, 0); put_le32(pb, -1); /* quality */ put_le32(pb, au_ssize); /* sample size */ put_le32(pb, 0); put_le16(pb, stream->width); put_le16(pb, stream->height); end_tag(pb, strh); if(stream->codec_type != CODEC_TYPE_DATA){ strf = start_tag(pb, "strf"); switch(stream->codec_type) { case CODEC_TYPE_VIDEO: put_bmp_header(pb, stream, codec_bmp_tags, 0); break; case CODEC_TYPE_AUDIO: if (put_wav_header(pb, stream) < 0) { av_free(avi); return -1; } break; default: return -1; } end_tag(pb, strf); } if (!url_is_streamed(pb)) { unsigned char tag[5]; int j; /* Starting to lay out AVI OpenDML master index. * We want to make it JUNK entry for now, since we'd * like to get away without making AVI an OpenDML one * for compatibility reasons. */ avi->indexes[i].entry = avi->indexes[i].ents_allocated = 0; avi->indexes[i].indx_start = start_tag(pb, "JUNK"); put_le16(pb, 4); /* wLongsPerEntry */ put_byte(pb, 0); /* bIndexSubType (0 == frame index) */ put_byte(pb, 0); /* bIndexType (0 == AVI_INDEX_OF_INDEXES) */ put_le32(pb, 0); /* nEntriesInUse (will fill out later on) */ put_tag(pb, avi_stream2fourcc(&tag[0], i, stream->codec_type)); /* dwChunkId */ put_le64(pb, 0); /* dwReserved[3] put_le32(pb, 0); Must be 0. */ for (j=0; j < AVI_MASTER_INDEX_SIZE * 2; j++) put_le64(pb, 0); end_tag(pb, avi->indexes[i].indx_start); } if( stream->codec_type == CODEC_TYPE_VIDEO && stream->sample_aspect_ratio.num>0 && stream->sample_aspect_ratio.den>0){ int vprp= start_tag(pb, "vprp"); AVRational dar = av_mul_q(stream->sample_aspect_ratio, (AVRational){stream->width, stream->height}); int num, den; av_reduce(&num, &den, dar.num, dar.den, 0xFFFF); put_le32(pb, 0); //video format = unknown put_le32(pb, 0); //video standard= unknown put_le32(pb, lrintf(1.0/av_q2d(stream->time_base))); put_le32(pb, stream->width ); put_le32(pb, stream->height); put_le16(pb, den); put_le16(pb, num); put_le32(pb, stream->width ); put_le32(pb, stream->height); put_le32(pb, 1); //progressive FIXME put_le32(pb, stream->height); put_le32(pb, stream->width ); put_le32(pb, stream->height); put_le32(pb, stream->width ); put_le32(pb, 0); put_le32(pb, 0); put_le32(pb, 0); put_le32(pb, 0); end_tag(pb, vprp); } end_tag(pb, list2); } if (!url_is_streamed(pb)) { /* AVI could become an OpenDML one, if it grows beyond 2Gb range */ avi->odml_list = start_tag(pb, "JUNK"); put_tag(pb, "odml"); put_tag(pb, "dmlh"); put_le32(pb, 248); for (i = 0; i < 248; i+= 4) put_le32(pb, 0); end_tag(pb, avi->odml_list); } end_tag(pb, list1); list2 = start_tag(pb, "LIST"); put_tag(pb, "INFO"); avi_write_info_tag(pb, "INAM", s->title); avi_write_info_tag(pb, "IART", s->author); avi_write_info_tag(pb, "ICOP", s->copyright); avi_write_info_tag(pb, "ICMT", s->comment); avi_write_info_tag(pb, "IPRD", s->album); avi_write_info_tag(pb, "IGNR", s->genre); if (s->track) { char str_track[4]; snprintf(str_track, 4, "%d", s->track); avi_write_info_tag(pb, "IPRT", str_track); } if(!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) avi_write_info_tag(pb, "ISFT", LIBAVFORMAT_IDENT); end_tag(pb, list2); /* some padding for easier tag editing */ list2 = start_tag(pb, "JUNK"); for (i = 0; i < 1016; i += 4) put_le32(pb, 0); end_tag(pb, list2); avi->movi_list = start_tag(pb, "LIST"); put_tag(pb, "movi"); put_flush_packet(pb); return 0; }