static int avi_write_trailer(AVFormatContext *s) { AVIContext *avi = s->priv_data; ByteIOContext *pb = &s->pb; int res = 0; int i, j, n, nb_frames; offset_t file_size; if (!url_is_streamed(pb)){ if (avi->riff_id == 1) { end_tag(pb, avi->movi_list); res = avi_write_idx1(s); end_tag(pb, avi->riff_start); } else { avi_write_ix(s); end_tag(pb, avi->movi_list); end_tag(pb, avi->riff_start); file_size = url_ftell(pb); url_fseek(pb, avi->odml_list - 8, SEEK_SET); put_tag(pb, "LIST"); /* Making this AVI OpenDML one */ url_fskip(pb, 16); for (n=nb_frames=0;n<s->nb_streams;n++) { AVCodecContext *stream = s->streams[n]->codec; if (stream->codec_type == CODEC_TYPE_VIDEO) { if (nb_frames < avi->packet_count[n]) nb_frames = avi->packet_count[n]; } else { if (stream->codec_id == CODEC_ID_MP2 || stream->codec_id == CODEC_ID_MP3) { nb_frames += avi->packet_count[n]; } } } put_le32(pb, nb_frames); url_fseek(pb, file_size, SEEK_SET); avi_write_counters(s, avi->riff_id); } } put_flush_packet(pb); for (i=0; i<MAX_STREAMS; i++) { for (j=0; j<avi->indexes[i].ents_allocated/AVI_INDEX_CLUSTER_SIZE; j++) av_free(avi->indexes[i].cluster[j]); av_free(avi->indexes[i].cluster); avi->indexes[i].cluster = NULL; avi->indexes[i].ents_allocated = avi->indexes[i].entry = 0; } return res; }
static void writeText( ByteStream & str_out, const GUTF8String &textUTF8, const DjVuTXT::Zone &zone, const int WindowHeight ) { // DEBUG_MSG( "--zonetype=" << zone.ztype << "\n" ); const GUTF8String xindent(indent( 2 * zone.ztype + 2 )); GPosition pos=zone.children; // Build attribute string if( ! pos ) { GUTF8String coords; coords.format("coords=\"%d,%d,%d,%d\"", zone.rect.xmin, WindowHeight - 1 - zone.rect.ymin, zone.rect.xmax, WindowHeight - 1 - zone.rect.ymax); const int start=zone.text_start; const int end=textUTF8.firstEndSpace(start,zone.text_length); str_out.writestring(start_tag(zone.ztype,coords)); str_out.writestring(textUTF8.substr(start,end-start).toEscaped()); str_out.writestring(end_tag(zone.ztype)); } else { writeText(str_out,textUTF8,zone.ztype,zone.children,WindowHeight); } }
result_type operator()(StoppableGenerator& gen) const { return result_type( iter_t(gen, begin_tag()), iter_t(gen, end_tag()) ); }
static int wav_write_trailer(AVFormatContext *s) { ByteIOContext *pb = s->pb; WAVContext *wav = s->priv_data; int64_t file_size; if (!url_is_streamed(s->pb)) { end_tag(pb, wav->data); /* update file size */ file_size = url_ftell(pb); url_fseek(pb, 4, SEEK_SET); put_le32(pb, (uint32_t)(file_size - 8)); url_fseek(pb, file_size, SEEK_SET); put_flush_packet(pb); if(s->streams[0]->codec->codec_tag != 0x01) { /* Update num_samps in fact chunk */ int number_of_samples; number_of_samples = av_rescale(wav->maxpts - wav->minpts + wav->last_duration, s->streams[0]->codec->sample_rate * (int64_t)s->streams[0]->time_base.num, s->streams[0]->time_base.den); url_fseek(pb, wav->data-12, SEEK_SET); put_le32(pb, number_of_samples); url_fseek(pb, file_size, SEEK_SET); put_flush_packet(pb); } } return 0; }
void config_write_end_tag(struct writeconfig *wc, const char *entity) { GString *outstr = g_string_sized_new(128); end_tag(outstr, entity); config_write(wc, outstr->str); g_string_free(outstr, TRUE); }
void inline parse_collection(FILE *collection) { char *buffer = new char[BUF_SIZE]; int size = 0; begin_indexing(); char c = getc(collection); while (c != EOF) { size = 0; // Token if (c == '<') { c = getc(collection); // End Tag if (c == '/') { c = getc(collection); while (c != '>' && isalnum(c)) { buffer[size++] = c; c = getc(collection); } if (c == '>') { buffer[size] = '\0'; end_tag(buffer); } else { printf("End tag error\n"); } // Start Tag } else { while (c != '>' && isalnum(c)) { buffer[size++] = c; c = getc(collection); } if (c == '>') { buffer[size] = '\0'; start_tag(buffer); } else { printf("End tag error\n"); } } } // Words // This is lazy, I know; but ambiguous cases are a nearly bottomless rabbit hole. // Furthermore, the WSJ doesn't escape & properly, so nither do I. if (isalpha(c)) { do { buffer[size++] = tolower(c); c = getc(collection); } while(isalpha(c)); buffer[size] = '\0'; word(buffer); continue; } c = getc(collection); } end_indexing(); }
void config_write_int(struct writeconfig *wc, int value, const char *entity, GHashTable *attr) { GString *outstr = g_string_sized_new(128); start_tag(outstr, entity, attr); g_string_sprintfa(outstr, "%d", value); end_tag(outstr, entity); config_write(wc, outstr->str); g_string_free(outstr, TRUE); }
void DjVuTXT::writeText(ByteStream &str_out,const int height) const { if(has_valid_zones()) { ::writeText(str_out,textUTF8,DjVuTXT::PAGE,page_zone.children,height); }else { str_out.writestring(start_tag(DjVuTXT::PAGE)); str_out.writestring(end_tag(DjVuTXT::PAGE)); } }
static int wav_write_header(AVFormatContext *s) { WAVContext *wav = s->priv_data; ByteIOContext *pb = s->pb; int64_t fmt, fact; put_tag(pb, "RIFF"); put_le32(pb, 0); /* file length */ put_tag(pb, "WAVE"); /* format header */ fmt = start_tag(pb, "fmt "); if (put_wav_header(pb, s->streams[0]->codec) < 0) { av_log(s, AV_LOG_ERROR, "%s codec not supported in WAVE format\n", s->streams[0]->codec->codec ? s->streams[0]->codec->codec->name : "NONE"); av_free(wav); return -1; } end_tag(pb, fmt); if(s->streams[0]->codec->codec_tag != 0x01 /* hence for all other than PCM */ && !url_is_streamed(s->pb)) { fact = start_tag(pb, "fact"); put_le32(pb, 0); end_tag(pb, fact); } av_set_pts_info(s->streams[0], 64, 1, s->streams[0]->codec->sample_rate); wav->maxpts = wav->last_duration = 0; wav->minpts = INT64_MAX; /* data header */ wav->data = start_tag(pb, "data"); put_flush_packet(pb); return 0; }
static GUTF8String tolayer(int &layer, const DjVuTXT::ZoneType next_layer) { GUTF8String retval; for( ;layer < (int)next_layer;layer++ ) { retval+=start_tag(layer); } while (layer > (int)next_layer ) { retval+=end_tag(--layer); } return retval; }
// xml_output_stream interface void write(xml_event const& ev) { switch( ev.type ) { case xml_event::START_ELEMENT: start_tag(ev.content, ev.attributes); break; case xml_event::END_ELEMENT: end_tag(ev.content); break; case xml_event::CDATA: char_data(ev.content); break; default: assert(false); } }
static int avi_write_idx1(AVFormatContext *s) { ByteIOContext *pb = &s->pb; AVIContext *avi = s->priv_data; offset_t idx_chunk; int i; char tag[5]; if (!url_is_streamed(pb)) { AVIIentry* ie = 0, *tie; int entry[MAX_STREAMS]; int empty, stream_id = -1; idx_chunk = start_tag(pb, "idx1"); memset(&entry[0], 0, sizeof(entry)); do { empty = 1; for (i=0; i<s->nb_streams; i++) { if (avi->indexes[i].entry <= entry[i]) continue; tie = avi_get_ientry(&avi->indexes[i], entry[i]); if (empty || tie->pos < ie->pos) { ie = tie; stream_id = i; } empty = 0; } if (!empty) { avi_stream2fourcc(&tag[0], stream_id, s->streams[stream_id]->codec->codec_type); put_tag(pb, &tag[0]); put_le32(pb, ie->flags); put_le32(pb, ie->pos); put_le32(pb, ie->len); entry[stream_id]++; } } while (!empty); end_tag(pb, idx_chunk); avi_write_counters(s, avi->riff_id); } return 0; }
void check_team_frozen( CHAR_DATA *ch ) { DESCRIPTOR_DATA *d, *d_next; char buf[MAX_STRING_LENGTH]; bool cblue = FALSE, cred = FALSE; if ( IS_NPC( ch ) || !ch->pcdata ) return; if ( xIS_SET( ch->act, PLR_BLUE ) ) cblue = TRUE; else if ( xIS_SET( ch->act, PLR_RED ) ) cred = TRUE; else return; for ( d = first_descriptor; d; d = d_next ) { d_next = d->next; if ( d->connected != CON_PLAYING || !d->character || IS_NPC( d->character ) ) continue; if ( !xIS_SET( d->character->act, PLR_PLAYING ) ) continue; if ( cblue && !xIS_SET( d->character->act, PLR_BLUE ) ) continue; if ( cred && !xIS_SET( d->character->act, PLR_RED ) ) continue; if ( !xIS_SET( d->character->act, PLR_FROZEN ) ) /* At least one person on the * team isn't * frozen */ return; } /* * If we made it this far then everyone on the team has been frozen */ snprintf( buf, sizeof( buf ), "&R[&WEvento de congelación&R] &WEl equipo %s &Wha ganado!!!", cblue ? "&RROJO" : "&CAZUL" ); tag_channel( NULL, buf ); end_tag( ); }
void config_write_string(struct writeconfig *wc, const char *value, const char *entity, GHashTable *attr) { GString *outstr = g_string_sized_new(1024); gunichar c; start_tag(outstr, entity, attr); for(c = g_utf8_get_char(value); c ; value = g_utf8_next_char(value), c = g_utf8_get_char(value)) { switch(c) { case '<': g_string_append(outstr, "<"); break; case '>': g_string_append(outstr, ">"); break; case '&': g_string_append(outstr, "&"); break; case '\'': g_string_append(outstr, "'"); break; case '"': g_string_append(outstr, """); break; default: g_string_append_unichar(outstr, c); } } end_tag(outstr, entity); config_write(wc, outstr->str); g_string_free(outstr, TRUE); }
void xml_writer_impl::write_element(const variant& element) { try { if (element.is<variant::Collection>() && element.empty() && element.type() != variant::DataTable) { write_empty_element(); return; } switch(element.type()) { case variant::None: { write_empty_element(); break; } case variant::Any: case variant::String: { if (element.as<std::string>().empty()) { write_empty_element(); break; } } case variant::Float: case variant::Double: case variant::Int32: case variant::UInt32: case variant::Int64: case variant::UInt64: case variant::Boolean: case variant::Date: case variant::Time: case variant::DateTime: { m_os << start_tag(); write_text(element); m_os << end_tag(); break; } case variant::Dictionary: case variant::Bag: { if ((m_mode & xml_mode::Preserve)!=0) { if (element.has_key(xml_attributes)) { m_stack.top().m_attributes = element[xml_attributes]; if (element.size()==1) { write_empty_element(); break; } } m_os << start_tag(); bool prev_is_text = false; variant::const_iterator it, end(element.end()); for (it=element.begin(); it!=end; ++it) { if (it.key()==xml_attributes) { continue; } else if (it.key()==xml_text) { write_text(it.value()); prev_is_text = true; } else if (it.key()==xml_instruction) { push(it.key()); if (!prev_is_text) { m_os << indent(); } write_instruction(it.value()); prev_is_text = false; pop(); } else if (it.key()==xml_comment) { push(it.key()); if (!prev_is_text) { m_os << indent(); } write_comment(it.value()); prev_is_text = false; pop(); } else { push(it.key()); if (!prev_is_text) { m_os << indent(); } write_element(it.value()); prev_is_text = false; pop(); } } if (!prev_is_text) { m_os << indent(); } m_os << end_tag(); } else { m_os << start_tag(); variant::const_iterator it, end(element.end()); for (it=element.begin(); it!=end; ++it) { push(it.key()); m_os << indent(); write_variant(it.value()); pop(); } m_os << indent() << end_tag(); } break; } case variant::List: { m_os << start_tag(); BOOST_FOREACH(const variant& item, element) { push(); m_os << indent(); write_variant(item); pop(); } m_os << indent(); m_os << end_tag(); break; } case variant::Tuple: { m_stack.top().m_attributes.insert("size", variant(element.size())); m_os << start_tag(); BOOST_FOREACH(const variant& item, element) { push(); m_os << indent(); write_variant(item); pop(); } m_os << indent(); m_os << end_tag(); break; } case variant::TimeSeries: { m_os << start_tag(); variant::const_iterator it, end = element.end(); for (it=element.begin(); it!=end; ++it) { push().insert("time", variant(it.time())); m_os << indent(); write_variant(it.value()); pop(); } m_os << indent(); m_os << end_tag(); break; } case variant::DataTable: { const data_table& dt = element.m_value.get<variant::DataTable>(); m_stack.top().m_attributes .insert("rows", variant(dt.size())) .insert("columns", variant(dt.columns().size())); m_os << start_tag(); if (!dt.columns().empty()) { push("Columns"); m_os << indent() << start_tag(); for (data_table::column_container_type::const_iterator column_iter = dt.columns().begin() ; column_iter != dt.columns().end() ; ++column_iter) { push("Column") .insert("name", variant(column_iter->name())) .insert("type", variant(variant::enum_to_string(column_iter->type()))); m_os << indent(); write_empty_element(); pop(); } m_os << indent() << end_tag(); pop(); } for (data_table::column_container_type::const_iterator column_iter = dt.columns().begin() ; column_iter != dt.columns().end() ; ++column_iter) { push("Column").insert("name", variant(column_iter->name())); m_os << indent() << start_tag(); if (column_iter->type() & variant_base::Primitive) { boost::scoped_ptr<data_table_column_writer> column_writer( make_data_table_column_stream_writer(*column_iter, m_os) ); while (column_writer->has_next()) { push("V"); m_os << indent() << start_tag(); column_writer->write(); m_os << end_tag(); pop(); column_writer->advance(); } } else { variant::const_iterator iter(column_iter->begin()); variant::const_iterator end(column_iter->end()); while (iter != end) { push("V"); m_os << indent(); write_variant(*(iter++)); pop(); } } m_os << indent() << end_tag(); pop(); } m_os << indent(); m_os << end_tag(); break; } case variant::Buffer: { m_os << start_tag(); const void *data = element.as<void*>(); size_t size = element.size(); if (data!=nullptr && size>0) { unsigned int n = 0; boost::scoped_ptr<char> b64(detail::b64_encode((const char*)data, (unsigned int)size, &n)); if (!b64.get()) { boost::throw_exception(variant_error("Unable to base64 encode data")); } m_os << b64.get(); } m_os << end_tag(); break; } case variant::Object: { const object& obj(element.as<object>()); // write class name m_stack.top().m_attributes .insert("class", variant(obj.name())) .insert("version", variant(obj.version())); m_os << start_tag(); // write parameter dictionary variant params; obj.deflate(params); push("params"); m_os << indent(); write_variant(params); pop(); m_os << indent(); m_os << end_tag(); break; } case variant::Exception: { m_os << start_tag(); exception_data e(element.as<exception_data>()); push("type"); m_os << indent(); write_element(variant(e.type())); pop(); push("message"); m_os << indent(); write_element(variant(e.message())); pop(); if (!e.source().empty()) { push("source"); m_os << indent(); write_element(variant(e.source())); pop(); } if (!e.stack().empty()) { push("stack"); m_os << indent(); write_element(variant(e.stack())); pop(); } m_os << indent(); m_os << end_tag(); break; } case variant::Array: { const typed_array& a(element.as<typed_array>()); m_stack.top().m_attributes .insert("size", variant(a.size())) .insert("type", variant(variant::enum_to_string(a.type()))); m_os << start_tag(); for (size_t i=0; i<a.size(); ++i) { push(); m_os << indent(); write_element(variant(a[i])); pop(); } m_os << indent(); m_os << end_tag(); break; } default: boost::throw_exception(variant_error("Case exhaustion: " + variant::enum_to_string(element.type()))); }
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; }
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; /* FourCC should really be set by the codec itself */ if (! stream->codec_tag) { stream->codec_tag = codec_get_bmp_tag(stream->codec_id); } /* 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); } 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; }
static int avi_write_idx1(AVFormatContext *s) { ByteIOContext *pb = &s->pb; AVIContext *avi = s->priv_data; offset_t file_size, idx_chunk; int i, n, nb_frames, au_byterate, au_ssize, au_scale; AVCodecContext *stream; unsigned char tag[5]; if (!url_is_streamed(pb)) { AVIIentry* ie = 0, *tie; int entry[MAX_STREAMS]; int empty, stream_id = -1; idx_chunk = start_tag(pb, "idx1"); memset(&entry[0], 0, sizeof(entry)); do { empty = 1; for (i=0; i<s->nb_streams; i++) { if (avi->indexes[i].entry <= entry[i]) continue; tie = avi_get_ientry(&avi->indexes[i], entry[i]); if (empty || tie->pos < ie->pos) { ie = tie; stream_id = i; } empty = 0; } if (!empty) { avi_stream2fourcc(&tag[0], stream_id, s->streams[stream_id]->codec.codec_type); put_tag(pb, &tag[0]); put_le32(pb, ie->flags); put_le32(pb, ie->pos); put_le32(pb, ie->len); entry[stream_id]++; } } while (!empty); end_tag(pb, idx_chunk); /* Fill in frame/sample counters */ file_size = url_ftell(pb); nb_frames = 0; for(n=0;n<s->nb_streams;n++) { if (avi->frames_hdr_strm[n] != 0) { stream = &s->streams[n]->codec; url_fseek(pb, avi->frames_hdr_strm[n], SEEK_SET); if (stream->codec_type == CODEC_TYPE_VIDEO) { put_le32(pb, stream->frame_number); if (nb_frames < stream->frame_number) nb_frames = stream->frame_number; } else { if (stream->codec_id == CODEC_ID_MP2 || stream->codec_id == CODEC_ID_MP3) { put_le32(pb, stream->frame_number); nb_frames += stream->frame_number; } else { parse_specific_params(stream, &au_byterate, &au_ssize, &au_scale); put_le32(pb, avi->audio_strm_length[n] / au_ssize); } } } } if (avi->frames_hdr_all != 0) { url_fseek(pb, avi->frames_hdr_all, SEEK_SET); put_le32(pb, nb_frames); } url_fseek(pb, file_size, SEEK_SET); } return 0; }
void parse(FILE *stream) { char buffer[MAX_WORD_LEN]; int c = 0, index = 0; while (EOF != (c = tolower(getc(stream)))) { switch (c) { case '<': /* Tags */ /* End the current word */ if (index) { buffer[index] = '\0'; clean_word(buffer); word(buffer); index = 0; } /* Get the next character and decide what to do next */ c = getc(stream); /* Case doesn't matter here */ switch (c) { case '/': /* End tags */ tag_section(buffer, stream); end_tag(buffer); break; default: /* Start tags */ c = ungetc(c, stream); if (EOF != c) { tag_section(buffer, stream); start_tag(buffer); } break; } break; case '&': /* Entity references */ entity_ref(stream); /*if (39 == entity_ref(stream)) ungetc(39, stream);*/ break; default: /* Plain text */ if (index == MAX_WORD_LEN) { fprintf(stderr, "Maximum word length exceeded!\n"); exit(EXIT_FAILURE); } if (isalnum(c) || c == 39) { if (c != 39 || index) { /* no ' allowed at the start */ buffer[index++] = c; } } else if (index) { buffer[index] = '\0'; clean_word(buffer); word(buffer); index = 0; } break; } } if (!feof(stream)) { /* Stop due to an error! */ perror("Parsing failure"); exit(EXIT_FAILURE); } }
void do_ftag( CHAR_DATA *ch, char *argument ) { CHAR_DATA *victim; ROOM_INDEX_DATA *loc; char arg1[MAX_INPUT_LENGTH]; char arg2[MAX_INPUT_LENGTH]; char buf[MAX_STRING_LENGTH]; if ( IS_NPC( ch ) ) return; argument = one_argument( argument, arg1 ); if ( !arg1 || arg1[0] == '\0' ) { send_to_char( "sintaxis: congelacion entrar\r\n", ch ); send_to_char( "para comunicarte usa los canales rojo o azul.\r\n", ch ); send_to_char( "para congelar o descongelar a alguien una vez haya empezado el evento usa el comando tocar.\r\n", ch ); if ( IS_IMMORTAL( ch ) ) { send_to_char( "\r\nSintaxis: congelacion reset\r\n", ch ); send_to_char( " congelacion next\r\n", ch ); send_to_char( " congelacion start\r\n", ch ); send_to_char( " congelacion rojo <player>\r\n", ch ); send_to_char( " congelacion azul <player>\r\n", ch ); } return; } if ( arena_prep || challenge || arena_underway ) { send_to_char( "Espera a que termine el evento actual de arena.\r\n", ch ); return; } if ( !str_cmp( arg1, "entrar" ) ) { if ( tag_game.status != TAG_ISWAIT ) { send_to_char( "no hay ningún evento de congelación activo.\r\n", ch ); return; } if ( xIS_SET( ch->act, PLR_PLAYING ) || xIS_SET( ch->act, PLR_WAITING ) ) { send_to_char( "ya estás jugando.\r\n", ch ); return; } if ( !( loc = get_room_index( FTAG_WAIT_ROOM ) ) ) { send_to_char( "Espera a que termine el que ya hay empezado.\r\n", ch ); return; } send_to_char( "Entras al evento de congelación.\r\n", ch ); char_from_room( ch ); char_to_room( ch, loc ); tag_game.playing += 1; do_look( ch, ( char * ) "auto" ); xSET_BIT( ch->act, PLR_WAITING ); xREMOVE_BIT( ch->act, PLR_FROZEN ); xSET_BIT( ch->act, PLR_PKSAFE ); ch->quest_curr += 5; ch->quest_accum += 5; ch_printf( ch, "¡Ganas 5 puntos de gloria por participar en el evento!\r\n" ); if ( ( fRed = !fRed ) ) { xSET_BIT( ch->act, PLR_RED ); xREMOVE_BIT( ch->act, PLR_BLUE ); send_to_char( "&W¡formas parte del equipo &RROJO&W!\r\n", ch ); tag_channel( ch, "&R[&WEvento de congelación&R] &W¡$n forma parte del equipo &RROJO&W!" ); } else { xSET_BIT( ch->act, PLR_BLUE ); xREMOVE_BIT( ch->act, PLR_RED ); send_to_char( "&W¡formas parte del equipo &CAZUL&W!\r\n", ch ); tag_channel( ch, "&R[&WEvento de congelación&R] &W¡$n forma parte del equipo &CAZUL&W!" ); } return; } if ( !str_cmp( arg1, "start" ) ) { if ( GET_MONEY( ch, CURR_SILVER ) < 10 ) { send_to_char ( "necesitas 10 monedas de plata para comenzar el evento.\r\n", ch ); return; } if ( tag_game.status != TAG_OFF ) { send_to_char( "ya hay un juego en progreso.\r\n", ch ); return; } GET_MONEY( ch, CURR_SILVER ) -= 10; tag_channel( NULL, "&R[&WEvento&R] &C¡Ha comenzado un evento de congelación! ¡Teclea '&Wcongelacion entrar&C' para unirte!" ); tag_game.status = TAG_ISWAIT; tag_game.timer = 3; tag_game.playing = 0; tag_game.next = -1; if ( !IS_IMMORTAL( ch ) ) { GET_MONEY( ch, CURR_SILVER ) -= 10; return; } return; } if ( !IS_IMMORTAL( ch ) ) { do_ftag( ch, ( char * ) "" ); return; } if ( !str_cmp( arg1, "next" ) ) { tag_game.next = atoi( argument ); ch_printf( ch, "El próximo juego comenzará en %d ticks.\r\n", tag_game.next ); return; } if ( !str_cmp( arg1, "reset" ) ) { end_tag( ); send_to_char( "Jugadores reseteados.\r\n", ch ); return; } argument = one_argument( argument, arg2 ); if ( arg2[0] == '\0' || ( str_cmp( arg1, "rojo" ) && str_cmp( arg1, "azul" ) ) ) { send_to_char( "sintaxis: congelacion rojo <player>\r\n", ch ); send_to_char( " Congelacion azul <player>\r\n", ch ); return; } if ( tag_game.status == TAG_ISPLAY ) { send_to_char( "El juego ya ha comenzado.\r\n", ch ); return; } if ( !( victim = get_char_world( ch, arg2 ) ) ) { send_to_char( "No está aquí.\r\n", ch ); return; } if ( IS_NPC( victim ) ) { send_to_char( "No puede jugar.\r\n", ch ); return; } if ( !( loc = get_room_index( FTAG_WAIT_ROOM ) ) ) { send_to_char( "El evento de congelación todavía no ha finalizado.\r\n", ch ); return; } send_to_char( "Alguien te une al evento de congelación.\r\n", victim ); char_from_room( victim ); char_to_room( victim, loc ); tag_game.playing += 1; do_look( victim, ( char * ) "auto" ); xSET_BIT( victim->act, PLR_WAITING ); xREMOVE_BIT( victim->act, PLR_FROZEN ); xSET_BIT( victim->act, PLR_PKSAFE ); if ( !str_cmp( arg1, "rojo" ) ) { xSET_BIT( victim->act, PLR_RED ); xREMOVE_BIT( victim->act, PLR_BLUE ); act( AT_WHITE, "¡Formas parte del equipo &RROJO&W!", ch, NULL, victim, TO_VICT ); act( AT_WHITE, "¡$N forma parte del equipo &RROJO&W!", ch, NULL, victim, TO_NOTVICT ); act( AT_WHITE, "¡$N forma parte del equipo &RROJO&W!", ch, NULL, victim, TO_CHAR ); } else if ( !str_cmp( arg1, "blue" ) ) { xSET_BIT( victim->act, PLR_BLUE ); xREMOVE_BIT( victim->act, PLR_RED ); act( AT_WHITE, "¡Formas parte del equipo &Cazul&W!", ch, NULL, victim, TO_VICT ); act( AT_WHITE, "¡$N forma parte del equipo &CAZUL&W!", ch, NULL, victim, TO_NOTVICT ); act( AT_WHITE, "¡$N forma parte del equipo &CAZUL&W!", ch, NULL, victim, TO_CHAR ); } }
static inline GUTF8String end_tag(const int layer) { return end_tag((const DjVuTXT::ZoneType)layer); }
/** HTML 문서를 parsing 하면서 text로 변환. */ int htmlParse::parse(stToken *tok, char *text, int maxlen) { int tok_val=0, prev_tok_val=0, prev_ch=0; int is_in_tag=0; uint4 tmp=0; int not_moved=0; char *start=text; stTagProc *curr_tag=0; //stTagProc **prev_tag=0; stEntityProc *ent_proc; int tag_depth=0; int is_in_BODY_tag=0; int is_in_A_tag=0; int is_in_PRE_tag=0; // 2003.11.8 int hlink_chars = 0; //int newline_delayed=0; // Optional Pair && Newline tag가 시작한 경우 TRUE //int dont_newline=0; // TRUE means "dont write newline" int pair_mark=0; int words_in_line=0; int b_tag_first_in_line=0; // 라인 첫머리에 B tag가 나온 경우 int glossary_marked=0; int is_glossary=0; tok->offset = 0; tok->line_num=1; *text = 0; maxlen -= 20; while(tok->offset < tok->src_len && (int)((uint4)text-(uint4)start) < maxlen) { tmp = tok->offset; htmlLex::get_token_mem(tok); #ifdef BUG if (tok->tok_len>=20) { printf("long tok: line=%d, tok_val=%d, CH=%c\n", tok->line_num, tok->tok_val, tok->src_mem[tok->offset-1]); fflush(stdout); printf("tok=%s\n", tok->tok_str); fflush(stdout); } #endif #ifdef DEB /* if (tok->tok_val==0 || tok->line_num==1) { printf("line=%d, tok_val=%d, CH=%c\n", tok->line_num, tok->tok_val, tok->src_mem[tok->offset-1]); printf("offset=%d, text-start=%d\n", tok->offset, text-start); } */ #endif if (text > start) { prev_ch = *(text-1); if (prev_ch=='\n') { words_in_line = 0; b_tag_first_in_line = 0; glossary_marked = 0; } } if (tok->tok_val == TOK_EOF) break; if (tok->tok_val == URL_CMNT) { //printf("%s", tok->tok_str); continue; } if (tok->offset==tmp) { #ifdef BUG //printf("parse(): offset not moved: line=%d, CH=%d(%c)\n", // tok->line_num, tok->src_mem[tok->offset-1], tok->src_mem[tok->offset-1]); #endif tok->offset++; if (++not_moved >= 2) break; else continue; } tok_val = tok->tok_val; if (tok_val == BTAG_BEGIN) { skip_to_two_token(tok, STRING, TAG_END); if (tok->tok_val != STRING) { // must be a HTML tag skip_to_token(tok, TAG_END); continue; } //prn_tabs(); //fprintf(log,"%s-->:%d :%d\n", tok->tok_str, tok->line_num, tok->offset); curr_tag = htmlTagEntity::tag_idx(tok->tok_str); if (curr_tag == NULL) { skip_to_token(tok, TAG_END); continue; } tag_depth++; #ifdef MAIN_TEXT_ONLY if (curr_tag->pair != Not_PAIR && is_in_BODY_tag && curr_tag!=htmlTagEntity::A_tag) push_tag(curr_tag, tag_depth, (int)((uint4)text-(uint4)start)); if (curr_tag==htmlTagEntity::BODY_tag) { is_in_BODY_tag = 1; } #endif if (curr_tag==htmlTagEntity::A_tag) { is_in_A_tag = 1; } else if (curr_tag==htmlTagEntity::PRE_tag) { is_in_PRE_tag = 1; } else if(curr_tag==htmlTagEntity::B_tag||curr_tag==htmlTagEntity::DT_tag) { if (words_in_line==0) b_tag_first_in_line = 1; } else if (curr_tag==htmlTagEntity::TITLE_tag) { get_hyperlink_title(tok->src_mem + tok->offset , htmlTitle, HTMLTITLE_LEN); #ifdef DEB PRN("tok->scr_mem=%X, offset=%d, title=%X\n", tok->src_mem, tok->offset, htmlTitle); PRN("title: %s (%d)\n", htmlTitle, strlen(htmlTitle) ); #endif is_glossary = is_glossay_mode(htmlTitle); } else if (curr_tag==htmlTagEntity::BR_tag) { *text++ = '\n'; } if (curr_tag->proc == 0) { // 0 if (curr_tag->pair != Not_PAIR) skip_ignore_part(tok, curr_tag); else skip_to_token(tok, TAG_END); if (curr_tag->newline) { if (prev_ch != '\n') *text++ = '\n'; } continue; } if (curr_tag==htmlTagEntity::TITLE_tag) { if (prev_ch != '\n') *text++ = '\n'; *text++ = '['; *text++ = '['; } else if (curr_tag->proc == 1) { } else if (!pair_mark && curr_tag->proc == 2) { pair_mark = 2; *text++ = '<'; } else if (!pair_mark && curr_tag->proc == 3) { pair_mark = 3; *text++ = '\''; } else if (!pair_mark && curr_tag->proc == 4) { pair_mark = 4; *text++ = '['; } else if (curr_tag->proc == 5) { if (prev_ch != '\n') *text++ = '\n'; *text++ = '*'; *text++ = ' '; words_in_line = 0; } else if (curr_tag->proc == 6) { if (prev_ch != '\n') *text++ = '\n'; *text++ = '\n'; } skip_to_token(tok, TAG_END); if (!pair_mark && prev_ch != ' ') *text++ = ' '; //if (!ISSPACE(*text)) *text++ = ' '; }// BTAG_BEGIN '<' else if (tok_val == ETAG_BEGIN) { skip_to_two_token(tok, STRING, TAG_END); if (tok->tok_val != STRING) { // must be a HTML tag skip_to_token(tok, TAG_END); continue; } curr_tag = htmlTagEntity::tag_idx(tok->tok_str); if (curr_tag == NULL) { skip_to_token(tok, TAG_END); continue; } #ifdef MAIN_TEXT_ONLY tag_depth--; if (curr_tag==htmlTagEntity::BODY_tag) { is_in_BODY_tag = 0; } if (curr_tag->pair != Not_PAIR && is_in_BODY_tag && curr_tag!=htmlTagEntity::A_tag) end_tag(curr_tag, (int)((uint4)text-(uint4)start)); #endif if (curr_tag==htmlTagEntity::A_tag) { is_in_A_tag = 0; #ifdef MARK_A_LINK *text++ = '}'; #endif } else if (curr_tag==htmlTagEntity::PRE_tag) { is_in_PRE_tag = 0; } else if(curr_tag==htmlTagEntity::DT_tag || (curr_tag==htmlTagEntity::B_tag && (b_tag_first_in_line && is_glossary))) { if (glossary_marked==0) { *text++ = ' '; *text++ = ':'; //*text++ = ' '; b_tag_first_in_line = 0; glossary_marked = 1; } } else if (curr_tag==htmlTagEntity::TITLE_tag) { *text++ = ']'; *text++ = ']'; *text++ = '\n'; } else if (curr_tag->proc == 1) { } else if (pair_mark==2 && curr_tag->proc == 2) { pair_mark = 0; *text++ = '>'; } else if (pair_mark==3 && curr_tag->proc == 3) { pair_mark = 0; *text++ = '\''; } else if (pair_mark==4 && curr_tag->proc == 4) { pair_mark = 0; *text++ = ']'; } else if (curr_tag->proc == 5) { } else if (curr_tag->proc == 6) { if (prev_ch != '\n') *text++ = '\n'; *text++ = '\n'; } if (curr_tag->newline) { *text++ = '\n'; } skip_to_token(tok, TAG_END); }// ETAG_BEGIN '</' else if (tok_val == STAG_END) { skip_to_token(tok, TAG_END); is_in_tag = 0; tag_depth--; } else if (tok_val == TAG_EXC) { tmp = skip_to_token(tok, TAG_END); //fprintf(log,"<- > skipped %d\n", tmp); } else if (tok_val == CMNT_BEGIN) { //fprintf(log,"Cmnt -->: %d :%d\n", tok->line_num, tok->offset); htmlLex::skip_to_cmnt_end(tok); //fprintf(log,"Cmnt <--: %d :%d\n", tok->line_num, tok->offset); } else if (tok_val == ENTITY_STR) { if (prev_ch !=' ') *text++ = ' '; //2002.12.2 ent_proc = htmlTagEntity::entity_idx(tok->tok_str); if (ent_proc && ent_proc->conv[0]) { #ifdef BUG //prn_ent_proc(ent_proc); #endif strcpy(text, ent_proc->conv); text += strlen(ent_proc->conv); } else { //fprintf(log,"ignored entity = %s\n", tok->tok_str); } } else if (tok_val == ENTITY_NUM) { if (prev_ch !=' ') *text++ = ' '; //2002.12.2 ent_proc = htmlTagEntity::entity_id_idx(tok->tok_realval); if (ent_proc && ent_proc->conv[0]) { #ifdef BUG //prn_ent_proc(ent_proc); #endif strcpy(text, ent_proc->conv); text += strlen(ent_proc->conv); } else { if (tok->tok_realval < 0x80) { // 2005.7.19 *text = (char)tok->tok_realval ; text++; } } } else { char *t = text; if (is_in_PRE_tag || tok->tok_len>1 || tok_val == STRING || tok_val == NUMBER) { //if (prev_tok_val == TAG_END && *text != ' ') *text++ = ' '; // 2003. 3.20 //if (prev_tok_val == TAG_END && isalnum(prev_ch) ) // *text++ = ' '; words_in_line++; strcpy(text, tok->tok_str); text += tok->tok_len; } // 2002.10.16 한글은 space로 전환 else if (tok->tok_val == FR_STR) { if (do_prn_hangul) { if (prev_ch != ' ') *text++ = ' '; strcpy(text, tok->tok_str); text += tok->tok_len; words_in_line++; } else { if (prev_ch != ' ') *text++ = ' '; } } else if (tok->tok_len==1) { if (curr_tag==htmlTagEntity::PRE_tag) { #ifdef ODD_CHAR if ( (tok_val & 0xF0) != 0x90) *text++ = tok_val; else if (tok_val==0x92) { if (prev_tok_val != 0x92) *text++ = '\''; } #else *text++ = tok_val; #endif } //else if (tok_val == '\n' || tok_val == '\r') { else if (ISSPACE(tok_val)) { if (prev_ch != ' ') *text++ = ' '; } else { if (prev_ch==':' && tok_val==':') { } else *text++ = tok_val; } } if (is_in_A_tag) hlink_chars += (int)(text - t); } prev_tok_val = tok->tok_val; }// while(1) *text = 0; if ((int)(text-start) >= maxlen-5) { PRN("parse(): too far !! maxlen=%d, %d\n", maxlen, text-start); } if ((int)(text-start) < maxlen-5) memset(text, 0, 4); #ifdef DEB PRN("text=%X, start=%X, text=%d, start=%d\n", text, start, (int)text % 10000, (int)start % 10000); PRN("start[0]=%d text[0]=%d\n", start[0], text[0]); #endif return ((int)text-(int)start); }