h264转MP4源码,编译通过
#ifndef H264_CONFIG_H
#define H264_CONFIG_H
#include
#include
#include "mp4conf.h"
extern int open_h264();
extern void rewind_h264();
extern uint8_t * read_nal_from_h264(int * size);
extern void close_h264();
#endif /* H264_CONFIG_H */
#ifndef MP4_CONFIG_H
#define MP4_CONFIG_H
//typedef long int64_t;
typedef unsigned long uint64_t;
typedef unsigned int uint32_t;
typedef unsigned char uint8_t;
#define UINT32_MAX 0xffffffff
#define INT32_MAX 0x7fffffff
#define H264_LANGUAGE 0x55C4
/*
----mvhd----:
timescale:1000 //一秒分1000份，表时间单位为1毫秒
duration:1556
----tkhd----:
duration:1554 //这个值对播放器很重要, 具体时间还和mvhd的timescale相关,用来指定了时长
----mdhd----:
timescale:24000 //决定了播放速度，不过他与duration的相乘后还是可以对应上面的mvhd设置
duration:37037
----samp----:
entry_count:1
sample_count:37 //上的duration时间，duration指整个mdat中video时长，37却为chunks数目
sample_delta:1001 //1001 * 37=37037 sample_delta*sample_count=duration
*/
/*----mvhd----*/
#define MOV_TIMESCALE (1000)
//#define MOV_MAX_TRACK_DURATION (0)
//timescale:MOV_TIMESCALE
//duration:
// FPS=MEDIA_TIMESCALE/MEDIA_SAMPLE_DURATION
// duration=帧数/FPS*MOV_TIMESCALE
// =帧数*MEDIA_SAMPLE_DURATION*MOV_TIMESCALE/MEDIA_TIMESCALE
/*----tkhd----*/
//duration:
// FPS=MEDIA_TIMESCALE/MEDIA_SAMPLE_DURATION
// duration=帧数/FPS*MOV_TIMESCALE
// =帧数*MEDIA_SAMPLE_DURATION*MOV_TIMESCALE/MEDIA_TIMESCALE
#define MOV_TIMESCALE_TO_MEDIA_TIMESCALE (30)
/*----mdhd----*/
#define MEDIA_TIMESCALE2 (MOV_TIMESCALE*MOV_TIMESCALE_TO_MEDIA_TIMESCALE) //使用在mdhd中
//timescale:MEDIA_TIMESCALE
//duration:MEDIA_SAMPLE_DURATION*帧数
/*----sample----*/
//#define MEDIA_SAMPLE_DURATION (1001)
//unsigned int MEDIA_SAMPLE_DURATION=1001; 该数值放在Mp4中便于多路互不影响
//entry_count:1
//sample_count:帧数
//sample_delta:MEDIA_SAMPLE_DURATION
//如上可得:
//MOV_TIMESCALE 及MEDIA_SAMPLE_DURATION 为定值,不影响播放
//MEDIA_TIMESCALE/MEDIA_SAMPLE_DURATION 决定了FPS:29.9帧率
#endif /* MP4_CONFIG_H */
#include
#include
#include
#include "mp4enc.h"
#include "mp4file.h"
//FIXME support 64 bit variant with wide placeholders
static int64_t updateSize(FILE *pb, int64_t pos)
{
int64_t curpos = mp4_ftell(pb);
mp4_fseek(pb, pos, SEEK_SET);
put_be32(pb, curpos - pos); /* rewrite size */
mp4_fseek(pb, curpos, SEEK_SET);
return curpos - pos;
}
//获取H.264的avcc参数
static int ff_isom_write_avcc(FILE *pfile, Mp4Context *mov)
{
if(mov->sps!=NULL&&mov->pps!=NULL)
{
put_buffer(pfile,"\x01\x4D\x40\x14\xFF\xE1",6);
put_be16(pfile,mov->sps_len);
put_buffer(pfile,mov->sps,mov->sps_len);
put_byte(pfile,01);
put_be16(pfile,4);//mov->pps_len);
put_buffer(pfile,mov->pps,mov->pps_len);
return 0;
}
else
{
return -1;
}
}
static int mov_write_tkhd_tag(FILE *pb, Mp4Context *mov)
{
int64_t duration = MOV_TIMESCALE;
int version = 0;
(version == 1) ? put_be32(pb, 104) : put_be32(pb, 92); /* size */ put_tag(pb, "tkhd");
put_byte(pb, version);
put_be24(pb, 0xf); /* flags (track enabled) */
if (version == 1)
{
put_be64(pb, mov->time);
put_be64(pb, mov->time);
}
else
{
put_be32(pb, mov->time);/* creation time */
put_be32(pb, mov->time);/* modification time */
}
put_be32(pb, 1);/* track-id */
put_be32(pb, 0); /* reserved */
//这个值对播放器很重要, 具体时间还和mvhd的timescale相关,用来指定了时长
(version == 1) ? put_be64(pb, mov->video_track_size*mov->MEDIA_SAMPLE_DURATION/MOV_TIMESCALE_TO_MEDIA_TIMES CALE): \
put_be32(pb,
mov->video_track_size*mov->MEDIA_SAMPLE_DURATION/MOV_TIMESCALE_TO_MEDIA_TIMES CALE);
put_be32(pb, 0); /* reserved */
put_be32(pb, 0); /* reserved */
put_be32(pb, 0x0); /* reserved (Layer & Alternate group) */
/* Volume, only for audio */
// if(track->enc->codec_type == AVMEDIA_TYPE_AUDIO) //注意以后的音视频流程差异，目前为视频
// put_be16(pb, 0x0100);
// else
put_be16(pb, 0);
put_be16(pb, 0); /* reserved */
/* Matrix structure */
put_be32(pb, 0x00010000); /* reserved */
put_be32(pb, 0x0); /* reserved */
put_be32(pb, 0x0); /* reserved */
put_be32(pb, 0x0); /* reserved */
put_be32(pb, 0x00010000); /* reserved */
put_be32(pb, 0x0); /* reserved */
put_be32(pb, 0x0); /* reserved */
put_be32(pb, 0x0); /* reserved */
put_be32(pb, 0x40000000); /* reserved */
/* Track width and height, for visual only */
// if(st && (track->enc->codec_type == AVMEDIA_TYPE_VIDEO ||
// track->enc->codec_type == AVMEDIA_TYPE_SUBTITLE)) {
// double sample_aspect_ratio = av_q2d(st->sample_aspect_ratio);
// if(!sample_aspect_ratio || track->height != track->enc->height)
// sample_aspect_ratio = 1;
put_be32(pb, mov->width/*sample_aspect_ratio * track->enc->width*0x10000*/);
put_be32(pb, mov->height/*track->height*0x10000*/);
return 0x5c;
}
static int mov_write_mdhd_tag(FILE *pb,Mp4Context *mov)
{
int version=0;
(version == 1) ? put_be32(pb, 44) : put_be32(pb, 32); /* size */
put_tag(pb, "mdhd");
put_byte(pb, version);
put_be24(pb, 0); /* flags */
if (version == 1)
{
put_be64(pb, mov->time);//track->time);
put_be64(pb, mov->time);//track->time);
}
else
{
put_be32(pb, mov->time);//track->time); /* creation time */
put_be32(pb, mov->time);//track->time); /* modification time */
}
put_be32(pb, MEDIA_TIMESCALE2);//track->timescale); /* time scale (sample rate for audio) */
(version == 1) ? put_be64(pb, mov->MEDIA_SAMPLE_DURATION*mov->video_track_size):\ put_be32(pb, mov->MEDIA_SAMPLE_DURATION*mov->video_track_size); /* duration */ put_be16(pb, H264_LANGUAGE);//track->language); /* language */
put_be16(pb, 0); /* reserved (quality) */
return 32;
}
static int mov_write_hdlr_tag(FILE *pb, Mp4Context *mov)
{
const char *hdlr, *descr = NULL, *hdlr_type = NULL;
int64_t pos = mp4_ftell(pb);
// if (!mov) { /* no media --> data handler */
// hdlr = "dhlr";
// hdlr_type = "url ";
// descr = "DataHandler";
// } else {
//hdlr = (track->mode == MODE_MOV) ? "mhlr" : "\0\0\0\0";
hdlr= "\0\0\0\0";
// if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) {
hdlr_type = "vide";
descr = "huangwm999@https://www.wendangku.net/doc/6e10996502.html,\0";
put_be32(pb, 0); /* size */
put_tag(pb, "hdlr");
put_be32(pb, 0); /* Version & flags */
put_buffer(pb, hdlr, 4); /* handler */
put_tag(pb, hdlr_type); /* handler type */
put_be32(pb ,0); /* reserved */
put_be32(pb ,0); /* reserved */
put_be32(pb ,0); /* reserved */
// if (!track || track->mode == MODE_MOV)
// put_byte(pb, strlen(descr)); /* pascal string */
put_buffer(pb, descr, strlen(descr)); /* handler description */
put_byte(pb, 0); //输出字符结束符\0 // if (track && track->mode != MODE_MOV)
// put_byte(pb, 0); /* c string */
return updateSize(pb, pos);
}
static int mov_write_vmhd_tag(FILE *pb)
{
put_be32(pb, 0x14); /* size (always 0x14) */
put_tag(pb, "vmhd");
put_be32(pb, 0x01); /* version & flags */
put_be64(pb, 0); /* reserved (graphics mode = copy) */
return 0x14;
}
static int mov_write_dref_tag(FILE *pb)
{
put_be32(pb, 28); /* size */
put_tag(pb, "dref");
put_be32(pb, 0); /* version & flags */
put_be32(pb, 1); /* entry count */
put_be32(pb, 0xc); /* size */
put_tag(pb, "url ");
put_be32(pb, 1); /* version & flags */
return 28;
}
static int mov_write_dinf_tag(FILE *pb)
{
int64_t pos = mp4_ftell(pb);
put_be32(pb, 0); /* size */
put_tag(pb, "dinf");
mov_write_dref_tag(pb);
return updateSize(pb, pos);
}
/* Time to sample atom */
static int mov_write_stts_tag(FILE *pb,Mp4Context *mov)
{
// MOVStts *stts_entries;
uint32_t entries = -1;
uint32_t atom_size;
uint32_t i;
entries=1;//mov->video_track_size;
atom_size = 16 + (entries * 8);
put_be32(pb, atom_size); /* size */
put_tag(pb, "stts");
put_be32(pb, 0); /* version & flags */
put_be32(pb, entries); /* entry count *///这个实例中记录所有sample的duration
for (i=0; i { put_be32(pb, mov->video_track_size);//H264_TRACK_ENTITY);//stts_entries[i].count); put_be32(pb, mov->MEDIA_SAMPLE_DURATION);//stts_entries[i].duration); } // av_free(stts_entries); return atom_size; } /* Sync sample atom */ static int mov_write_stss_tag(FILE *pb, Mp4Context *mov)//*nal_list *track*/, uint32_t flag) { int64_t curpos, entryPos; int i, index = 0; int64_t pos = mp4_ftell(pb); nal_list * head=mov->video_track; put_be32(pb, 0); // size //put_tag(pb, flag == MOV_SYNC_SAMPLE ? "stss" : "stps"); put_tag(pb, "stss"); put_be32(pb, 0); // version & flags entryPos = mp4_ftell(pb); //put_be32(pb, track->entry); // entry count put_be32(pb, 1); // entry count i=0; while(head!=NULL) { if(head->nal_type==1) { put_be32(pb, i+1); index++; } i++; head=head->next; } curpos = mp4_ftell(pb); mp4_fseek(pb, entryPos, SEEK_SET); put_be32(pb, index); // rewrite size mp4_fseek(pb, curpos, SEEK_SET); return updateSize(pb, pos); } /* Sample to chunk atom */ static int mov_write_stsc_tag(FILE *pb, Mp4Context *mov) { int index = 0, oldval = -1; int64_t entryPos, curpos; int64_t pos = mp4_ftell(pb); put_be32(pb, 0); /* size */ put_tag(pb, "stsc"); put_be32(pb, 0); // version & flags entryPos = mp4_ftell(pb); put_be32(pb, mov->video_track_size);//track->entry); // entry count //for (i=0; i //if(oldval != track->cluster[i].samplesInChunk) //{ put_be32(pb, 1); // first chunk put_be32(pb, 1);//track->cluster[i].samplesInChunk); // samples per chunk put_be32(pb, 0x1); // sample description index // oldval = track->cluster[i].samplesInChunk; // index++; //} //} index=1; curpos = mp4_ftell(pb); mp4_fseek(pb, entryPos, SEEK_SET); put_be32(pb, index); // rewrite size mp4_fseek(pb, curpos, SEEK_SET); return updateSize(pb, pos); } /* Sample size atom */ static int mov_write_stsz_tag(FILE *pb, Mp4Context *mov) { int equalChunks = 1; uint32_t i; //int j, entries = 0, tst = -1, oldtst = -1; nal_list * track=mov->video_track; int64_t pos = mp4_ftell(pb); put_be32(pb, 0); /* size */ put_tag(pb, "stsz"); put_be32(pb, 0); /* version & flags */ put_be32(pb, 0); // sample size put_be32(pb, mov->video_track_size); // sample count for (i=0; i { //if(one_node->nal_type!=2&&one_node->nal_type!=3){ put_be32(pb,track->nal_size); track=track->next; //} } return updateSize(pb, pos); } /* Chunk offset atom */ static int mov_write_stco_tag(FILE *pb, Mp4Context *mov) { uint32_t i; int mode64 = 0; // use 32 bit size variant if possible uint32_t offset_begin=mov->mdat_pos+8; //获取mdat起始文件偏移int64_t pos = mp4_ftell(pb); nal_list * track=mov->video_track; put_be32(pb, 0); /* size */ if (pos > UINT32_MAX) { mode64 = 1; put_tag(pb, "co64"); } else put_tag(pb, "stco"); put_be32(pb, 0); /* version & flags */ put_be32(pb, mov->video_track_size); /* entry count */ for (i=0; i { if(mode64 == 1) put_be64(pb, offset_begin+track->nal_offset);//文件偏移地址else put_be32(pb, offset_begin+track->nal_offset); track=track->next; } return updateSize(pb, pos); } static int mov_write_avcc_tag(FILE *pb, Mp4Context *mov) { int64_t pos = mp4_ftell(pb); put_be32(pb, 0); put_tag(pb, "avcC"); ff_isom_write_avcc(pb, mov); return updateSize(pb, pos); } static int mov_write_video_tag(FILE *pb, Mp4Context *mov) { int64_t pos = mp4_ftell(pb); char compressor_name[32]; put_be32(pb, 0); /* size */ //put_le32(pb, H264_TRACK_TAG);// store it byteswapped put_tag(pb,"avc1"); put_be32(pb, 0); /* Reserved */ put_be16(pb, 0); /* Reserved */ put_be16(pb, 1); /* Data-reference index */ put_be16(pb, 0); /* Codec stream version */ put_be16(pb, 0); /* Codec stream revision (=0) */ // if (track->mode == MODE_MOV) { // put_tag(pb, "FFMP"); /* Vendor */ // if(track->enc->codec_id == CODEC_ID_RAWVIDEO) { // put_be32(pb, 0); /* Temporal Quality */ // put_be32(pb, 0x400); /* Spatial Quality = lossless*/ // } else { // put_be32(pb, 0x200); /* Temporal Quality = normal */ // put_be32(pb, 0x200); /* Spatial Quality = normal */ // } // } else { put_be32(pb, 0); /* Reserved */ put_be32(pb, 0); /* Reserved */ put_be32(pb, 0); /* Reserved */ // } put_be16(pb, mov->width/*track->enc->width*/); /* Video width */ put_be16(pb, mov->height/*track->height*/); /* Video height */ put_be32(pb, 0x00480000); /* Horizontal resolution 72dpi */ put_be32(pb, 0x00480000); /* Vertical resolution 72dpi */ put_be32(pb, 0); /* Data size (= 0) */ put_be16(pb, 1); /* Frame count (= 1) */ memset(compressor_name,0,32); /* FIXME not sure, ISO 14496-1 draft where it shall be set to 0 */ // if (track->mode == MODE_MOV && track->enc->codec && track->enc->codec->name) // strncpy(compressor_name,track->enc->codec->name,31);//有问题 put_byte(pb, strlen(compressor_name)); put_buffer(pb, compressor_name, 31); // if (track->mode == MODE_MOV && track->enc->bits_per_coded_sample) // put_be16(pb, track->enc->bits_per_coded_sample); // else put_be16(pb, 0x18); /* Reserved */ put_be16(pb, 0xffff); /* Reserved */ // if(track->tag == MKTAG('m','p','4','v')) // mov_write_esds_tag(pb, mov); // else if(track->enc->codec_id == CODEC_ID_H263) // mov_write_d263_tag(pb); // else if(track->enc->codec_id == CODEC_ID_SVQ3) // mov_write_svq3_tag(pb); // else if(track->enc->codec_id == CODEC_ID_DNXHD) // mov_write_avid_tag(pb, mov); // else if(track->enc->codec_id == CODEC_ID_H264) { mov_write_avcc_tag(pb, mov); // if(track->mode == MODE_IPOD) // mov_write_uuid_tag_ipod(pb); // } else if(track->vosLen > 0) // mov_write_glbl_tag(pb, mov); return updateSize(pb, pos); } static int mov_write_stsd_tag(FILE *pb, Mp4Context *mov) { int64_t pos = mp4_ftell(pb); put_be32(pb, 0); /* size */ put_tag(pb, "stsd"); put_be32(pb, 0); /* version & flags */ put_be32(pb, 1); /* entry count */ // if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) //目前仅做视频mov_write_video_tag(pb, mov); // else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO) // mov_write_audio_tag(pb, mov); return updateSize(pb, pos); } static int mov_write_stbl_tag(FILE *pb, Mp4Context *mov) { int64_t pos = mp4_ftell(pb); put_be32(pb, 0); /* size */ put_tag(pb, "stbl"); mov_write_stsd_tag(pb, mov); mov_write_stts_tag(pb, mov); mov_write_stss_tag(pb, mov); mov_write_stsc_tag(pb, mov); mov_write_stsz_tag(pb, mov); mov_write_stco_tag(pb, mov); return updateSize(pb, pos); } static int mov_write_minf_tag(FILE *pb, Mp4Context *mov) { int64_t pos = mp4_ftell(pb); put_be32(pb, 0); /* size */ put_tag(pb, "minf"); /* if(track->enc->codec_type == AVMEDIA_TYPE_VIDEO)*/ mov_write_vmhd_tag(pb); mov_write_dinf_tag(pb); mov_write_stbl_tag(pb, mov); return updateSize(pb, pos); } static int mov_write_mdia_tag(FILE *pb, Mp4Context *mov) { int64_t pos = mp4_ftell(pb); put_be32(pb, 0); /* size */ put_tag(pb, "mdia"); mov_write_mdhd_tag(pb, mov); mov_write_hdlr_tag(pb, mov); mov_write_minf_tag(pb, mov); return updateSize(pb, pos); } // This box seems important for the psp playback ... without it the movie seems to hang static int mov_write_edts_tag(FILE *pb, Mp4Context *mov) { put_be32(pb, 0x24); /* size */ put_tag(pb, "edts"); put_be32(pb, 0x1c); /* size */ put_tag(pb, "elst"); put_be32(pb, 0x0); put_be32(pb, 0x1); /* duration ... doesn't seem to effect psp */ put_be32(pb,mov->MEDIA_SAMPLE_DURATION*mov->video_track_size); //put_be32(pb, track->cluster[0].cts); /* first pts is cts since dts is 0 */ put_be32(pb,0); put_be32(pb, 0x00010000); return 0x24; } static int mov_write_trak_tag(FILE *pb, Mp4Context *mov) { int64_t pos = mp4_ftell(pb); put_be32(pb, 0); /* size */ put_tag(pb, "trak"); mov_write_tkhd_tag(pb, mov); // if (track->mode == MODE_PSP || track->flags & MOV_TRACK_CTTS) mov_write_edts_tag(pb, mov); // PSP Movies require edts box // if (track->tref_tag) // mov_write_tref_tag(pb, mov); mov_write_mdia_tag(pb, mov); return updateSize(pb, pos); } static int mov_write_mvhd_tag(FILE *pb, Mp4Context *mov) { int maxTrackID = 1; int64_t maxTrackDuration = 0; int version; //视频的总时间=一个track的总时间 maxTrackDuration=mov->video_track_size*mov->MEDIA_SAMPLE_DURATION/MOV_TIMESCALE _TO_MEDIA_TIMESCALE; //version = maxTrackDuration < UINT32_MAX ? 0 : 1; version = 0; //定义为不超过4G的Mp4 (version == 1) ? put_be32(pb, 120) : put_be32(pb, 108); /* size */ put_tag(pb, "mvhd"); put_byte(pb, version); put_be24(pb, 0); /* flags */ if (version == 1) { put_be64(pb, mov->time); put_be64(pb, mov->time); } else { put_be32(pb, mov->time); /* creation time */ //时间的格式HFS时间 put_be32(pb, mov->time); /* modification time */ } put_be32(pb, MOV_TIMESCALE); (version == 1) ? put_be64(pb, maxTrackDuration) : put_be32(pb, maxTrackDuration); /* duration of longest track */ put_be32(pb, 0x00010000); /* reserved (preferred rate) 1.0 = normal */ put_be16(pb, 0x0100); /* reserved (preferred volume) 1.0 = normal */ put_be16(pb, 0); /* reserved */ put_be32(pb, 0); /* reserved */ put_be32(pb, 0); /* reserved */ /* Matrix structure */ put_be32(pb, 0x00010000); /* reserved */ put_be32(pb, 0x0); /* reserved */ put_be32(pb, 0x0); /* reserved */ put_be32(pb, 0x0); /* reserved */ put_be32(pb, 0x00010000); /* reserved */ put_be32(pb, 0x0); /* reserved */ put_be32(pb, 0x0); /* reserved */ put_be32(pb, 0x0); /* reserved */ put_be32(pb, 0x40000000); /* reserved */ put_be32(pb, 0); /* reserved (preview time) */ put_be32(pb, 0); /* reserved (preview duration) */ put_be32(pb, 0); /* reserved (poster time) */ put_be32(pb, 0); /* reserved (selection time) */ put_be32(pb, 0); /* reserved (selection duration) */ put_be32(pb, 0); /* reserved (current time) */ put_be32(pb, maxTrackID+1); /* Next track id */ return 0x6c; } static int mov_write_moov_tag(FILE *pb, Mp4Context *mov) { int64_t pos = mp4_ftell(pb); put_be32(pb, 0); /* size placeholder*/ put_tag(pb, "moov"); mov_write_mvhd_tag(pb, mov); mov_write_trak_tag(pb, mov); return updateSize(pb, pos); } static int mov_write_trailer(FILE *pb,Mp4Context *mov) { int res = 0; int64_t moov_pos = mp4_ftell(pb); /* Write size of mdat tag */ if (mov->mdat_size+8 <= UINT32_MAX) { mp4_fseek(pb, mov->mdat_pos, SEEK_SET); put_be32(pb, mov->mdat_size+8); } else { /* overwrite 'wide' placeholder atom */ mp4_fseek(pb, mov->mdat_pos - 8, SEEK_SET); put_be32(pb, 1); /* special value: real atom size will be 64 bit value after tag field */ put_tag(pb, "mdat"); put_be64(pb, mov->mdat_size+16); } mp4_fseek(pb, moov_pos, SEEK_SET); //-------------------------------------- //以上写入mdat成功 //-------------------------------------- mov_write_moov_tag(pb, mov); return res; } /* TODO: This needs to be more general */ static int mov_write_ftyp_tag(FILE *pb, Mp4Context * mov) { int64_t pos = mp4_ftell(pb); put_be32(pb, 0); /* size */ put_tag(pb, "ftyp"); put_tag(pb,"3gp6"); put_be32(pb, 0x00000100); put_tag(pb,"3gp6"); put_tag(pb, "3gp5"); put_tag(pb, "3gp4"); put_tag(pb, "avc1"); return updateSize(pb, pos); } static int mov_write_mdat_tag(FILE *pb, Mp4Context *mov) { put_be32(pb, 8); // placeholder for extended size field (64 bit) put_tag(pb, "wide");//mov->mode == MODE_MOV ? "wide" : "free"); mov->mdat_pos = mp4_ftell(pb); put_be32(pb, 0); /* size placeholder*/ put_tag(pb, "mdat"); return 0; } static int mov_write_header(FILE *pb,Mp4Context * mov) { int hint_track = 0; mov_write_ftyp_tag(pb,mov); mov_write_mdat_tag(pb, mov); return 0; } //-------------------------轻量级nal_list----------------------------- void nal_list_insert_end( nal_list* new_node,Mp4Context *mov ) { new_node->next=NULL; mov->video_track_size++; if(mov->video_track==NULL) //处理第一个帧的问题 { mov->video_track=new_node; } else { mov->tail->next=new_node; } mov->tail=new_node; return; } uint32_t nal_list_get_size(Mp4Context *mov) { return mov->video_track_size; } nal_list * nal_list_get_head(Mp4Context *mov) { return mov->video_track; } void nal_list_free(Mp4Context *mov) { while(mov->video_track!=NULL) { nal_list * p1=mov->video_track; mov->video_track=mov->video_track->next; free(p1); } mov->video_track=mov->tail=NULL; //清空头与尾 return; } //-------------------------主函数测试----------------------------- #if 1 #define DATA_MAX 3000000 int main( int argc, char **argv ) { Mp4Context * mov=malloc(sizeof(Mp4Context)); FILE * fp=mp4_fopen("result.mp4","wb"); unsigned char data[DATA_MAX]; int nal_list_len=0; int nal_list_it=0; nal_list * nal_list_head=NULL; uint64_t size=0; uint64_t sum_size=0; uint8_t * buf=NULL; nal_list *one_node=NULL; //uint32_t max_nal=6; memset(mov,0,sizeof(Mp4Context)); mov->mp4_fp=fp; mov->time=0xC6BFDE31; mov_write_header(mov->mp4_fp,mov);//写了Mp4的头部与mdat的头部 int b_eof = 0; int i_data = 0; FILE *fin = fopen("1.264","rb"); /* 打开要转换的h264文件流*/ if( fin == NULL ) { fprintf( stderr, "cannot open input file\n" ); return -1; } /* split frame */ while(1) { uint8_t *p, *p_next, *end; int i_size=0; /* fill buffer */ if( i_data < DATA_MAX && !b_eof ) { /*每次最大读入3000000个字节，约3M*/ int i_read = fread( &data[i_data], 1, DATA_MAX - i_data, fin ); if( i_read <= 0 ) b_eof = 1; else i_data += i_read; } if( i_data < 3 ) { break; } /*找到数组尾部*/ end = &data[i_data]; /* Search begin of a NAL */ p = &data[0]; while( p < end - 3 ) { if( p[0] == 0x00 && p[1] == 0x00 && p[2] == 0x01 ) { /* 找到退出循环*/ break; } p++; } /*如果没有找到，则将此数据丢弃*/ if( p >= end - 3 ) { fprintf( stderr, "garbage (i_data = %d)\n", i_data ); i_data = 0; continue; } /* Search end of NAL */ p_next = p + 3; while( p_next < end - 3 ) { if( p_next[0] == 0x00 && p_next[1] == 0x00 && p_next[2] == 0x01 ) { break; } p_next++; } if( p_next == end - 3 && i_data < DATA_MAX ) p_next = end; /* Compute NAL size */ i_size = p_next - p - 3; if( i_size <= 0 ) { if( b_eof ) break; fprintf( stderr, "nal too large (FIXME) ?\n" ); i_data = 0; continue; } /* 处理这一个NAL的数据*/ size = i_size +3; buf = p-1; int nal_type=0; int buf_it=0; //printf("offset:%d\tsize:%x\n",sum_size,size); //------------------保存分析结果------------------------------ if(size<5) //无法进行类型判断故不做分析{ //free(buf); continue; } 课程设计报告 ( 2013-- 2014年度第1学期) 名称：编译技术课程设计B 题目：简单编译程序的设计与实现院系：计算机系 班级：XXX 学号：XXX 学生姓名：XXX 指导教师：XXX 设计周数：XXX 成绩： 日期：XX 年XX 月 实验一．词法分析器的设计与实现 一、课程设计(综合实验)的目的与要求 1.1 词法分析器设计的实验目的 本实验是为计算机科学与技术专业的学生在学习《编译技术》课程后，为加深对课堂教学内容的理解，培养解决实际问题能力而设置的实践环节。通过这个实验，使学生应用编译程序设计的原理和技术设计出词法分析器，了解扫描器的组成结构，不同种类单词的识别方法。能使得学生在设计和调试编译程序的能力方面有所提高。为将来设计、分析编译程序打下良好的基础。 1.2 词法分析器设计的实验要求 设计一个扫描器，该扫描器是一个子程序，其输入是源程序字符串，每调用一次识别并输出一个单词符号。为了避免超前搜索，提高运行效率，简化扫描器的设计，假设该程序设计语言中，基本字（也称关键词）不能做一般标识符用，如果基本字、标识符和常数之间没有确定的运算符或界符作间隔，则用空白作间隔。 单词符号及其内部表示如表1-1所示，单词符号中标识符由一个字母后跟多个字母、数字组成，常数由多个十进制数字组成。单词符号的内部表示，即单词的输出形式为二元式：（种别编码,单词的属性值）。 表1-1 单词符号及其内部表示 二、设计（实验）正文 1.词法分析器流程图 2.词法分析器设计程序代码 // first.cpp : 定义控制台应用程序的入口点。// #include"stdafx.h" #include Android源码编译 开发工具:Ubuntu10.04 在Ubuntu下使用root用户登录，注意root一开始是锁定的，使用如下命令解锁:sudopasswd root 按回车铵，提示输入当前密码，在提示输入二次密码。输入完成切换用户使用root用户登录。 Android源码结构 Makefile （全局的Makefile） bionic （Bionic含义为仿生，这里面是一些基础的库的源代码） bootloader（引导加载器） build （build目录中的内容不是目标所用的代码，而是编译和配置所需要的脚本和工具） dalvik （JAVA虚拟机） development（程序开发所需要的模板和工具） external （目标机器使用的一些库） frameworks （应用程序的框架层） hardware （与硬件相关的库） kernel （Linux2.6的源代码） packages （Android的各种应用程序） prebuil （Android在各种平台下编译的预置脚本） recovery （与目标的恢复功能相关） system （Android的底层的一些库） Out (编译好的文件) 编译Android源码必需的安装的软件包 g++库文件有可能Ubuntu自带，使用g++ -v命令查找是否安装,如果没有自带请手动安装，使用如下命令，sudo apt-get-install g++-4.4. 注意：g++分很多版本，如果使用了最新版本4.6将没办法编译，建议安装4.4版本 Gcc库文件有可能Ubuntu自带，使用gcc–v命令查找是否安装,如果没有自带使用如下命令手动安装，sudo apt-get-install gcc-4.4. 注意：gcc分很多版本，如果使用了最新版本4.6将没办法编译，建议安装4.4版本 不过还有一些应该是linux系统自带的，如果缺少就按照提示install一下sudo apt-get install build-essential sudo apt-get install make sudo apt-get install libc6-dev sudo apt-get install patch sudo apt-get install texinfo sudo apt-get install libncurses-dev 深圳大学实验报告 课程名称：Linux操作系统 实验项目名称：Linux上C程序编译,调试和工程文件管理学院：计算机与软件学院 专业：软件工程 指导教师：冯禹洪 报告人：文成学号：2011150259 班级：02 实验时间：2013/12/31 实验报告提交时间：2013/12/31 教务处制 一、实验目标： 熟悉Linux上C程序设计环境，包括以下内容： 1. 联机帮助man命令 2. 编译工具gcc的使用 3. 熟悉使用gdb来调试程序 4. 熟悉C工程文件的管理工具makefile 二、实验环境与工件 湖边Linux实验室 Fedora 13 三、实验内容与步骤 1.动态库函数可以在多个应用程序之间共享，可以减少应用程序文件的容量和 应用程序的装载时间。因此，熟悉构建动态库可以提高软件的编写质量。请跟随以下步骤构建动态库message,并用其编写程序、编译和运行。（40分） 1.1编写源程序message.c（见图1）和main.c（见图2） 图1. message.c源程序 图2.main.c源程序 1.2用以下命令对message.c进行编译，其中，“-fPIC”选项是告诉gcc产生的 代码不要包含对函数和变量具体内存位置的引用。 1.3以上命令将获得目标文件message.o,使用以下命令建立共享函数库 message： 1.4使用1.3获得的共享函数库来编译main.c文件 1.5设置共享函数库搜索路径 1.6运行程序并附上结果 1.7构建静态可执行程序 1.7.1$gcc –c message.c 1.7.2$ar –crv libmsg.a message.o 1.7.3$gcc –o main main.c –L./ -lmsg 1.7.4$./main 1.8运行以下两个命令并截图说明结果： $ldd goodbye $ldd main $ls –l goodbye main /*附加题：经观察，如果用ubuntu, main 和googbye的大小在一些发行版本下没有区别，如果实验如此，请尝试解释这一现象。附加题目，平时成绩+5分，超过40分不算。*/ 2.图3-4中的reverse程序是有bug的，请使用gdb去观察程序的行为，对关键 行为截图说明，定位错误（截图说明）并修正程序bug。附上修正的程序及其运行结果。（40分） 图3. reverse.h头文件 Android源代码由两部分组成，其一是Android系统应用部分的代码，其次是Android 所使用的内核代码，如果针对Google Nexus S来开发ROM，就需要下载三星的内核代码Android 系统应用代码： https://https://www.wendangku.net/doc/6e10996502.html,/platform/manifest Android内核代码： https://https://www.wendangku.net/doc/6e10996502.html,/kernel/samsung.git 准备阶段：设置Linux编译环境（本人是Ubuntu 11.10 ，32位系统），一般你需要以下配置: Python 2.5 -- 2.7. GNU Make 3.81 -- 3.82,, JDK 6 (for Gingerbread or newer); JDK 5( for Froyo or older). Git 1.7 or newer. 1、安装一些必备的包。 Git是Linux Torvalds为了帮助管理Linux内核而开发的一个开放源码的分布式版本控制系统软件，它不同于SVN，CVS这样集中式的版本控制系统。在集中式版本控制系统中只有一个仓库(repository)，许多个工作目录，而git这样的分布式控制系统中，每一个工作目录都包含一个完整仓库，它们支持离线工作，本地提交可以稍后提交到服务器上。分布式系统理论上也比集中式的单服务器系统更健壮，单服务器系统一旦服务器出现问题整个系统就不能运行了，分布式系统通常不会因为一两个节点而收到影响? 因为Android是由kernel,Dalvik,Bionic,prebuild,build等多个Git项目组成， 所以Android项目编写了一个名为repo的python的脚本来统一管理这些项目的仓库，使得Git的使用更加简单。 $ sudo apt-get install git-core gnupg flex bison gperf build-essential \ zip curl zlib1g-dev libc6-dev lib32ncurses5-dev ia32-libs \ x11proto-core-dev libx11-dev lib32readline5-dev lib32z-dev \ libgl1-mesa-dev g++-multilib mingw32 tofrodos python-markdown \ libxml2-utils xsltproc $ sudo apt-get install libx11-dev:i386 2、创建源代码目录 首先确保在当前用户的主目录下创建一个/bin目录（如果没有的话），然后把它加到PATH 环境变量中： $ mkdir ~/bin $ PATH=~/bin:$PATH 或者$export PATH=$PATH:~/bin 3、用curl下载repo脚本，并保存在~/bin/repo文件中： $ curl https://https://www.wendangku.net/doc/6e10996502.html,/dl/googlesource/git-repo/repo > ~/bin/repo 为repo加上执行权限 $ chmod a+x ~/bin/repo 4、初始化版本库 首先建立一个目录，用来存放下载下来的东西 $mkdir MyAndroid $cd MyAndroid 以后，执行如下命令 $ repo init -u https://https://www.wendangku.net/doc/6e10996502.html,/platform/manifest -b android-2.3.7_r1 我这里下载的是android2.3.7版本的，所用的参数是android-2.3.7_r1。由于最新的是android-4.0.3_r1，所以使用上面即可下载2.3.7的源代码 注意：如果要是把所有的版本都下载下来，那时间是需要很久很久的，需要耐心等待，但是如果仅仅是下载某一个版本的话，还是很快就可以了。 最后，如果看到repo initialized in /MyAnroid的提示，说明本地的版本库已经初始化成功了（期间需要你填写姓名和Gmail地址）。 VC++6.0中如何编译运行调试C语言程序1.启动VC++6.0 （如下图） 2.单个源文件的编译运行 例如下面的源代码 #include 打开VC++6.0，如图1所示 （图1）选择“文件”→“新建”，打开如图2所示 （图2） 选择“文件”项，如图3所示 （图3） 选择“C++ Source File”项，并在“文件名”项目下输入“sum.c”如图4所示 （图4） 单击“确定”，打开如图5所示 （图5） 输入如上源代码，如图6所示 （图6） 选择按编译按钮调试程序，看看有没有错误，有的话改正，没有的话就可以再按连接按钮检查连接（多文件工程时常用，检查文件间是否正常连接）。 （图7） 在下端的输出窗口会有错误和警告的提示，如果没有错误选择“执行”（或按Ctrl+F5组合键）即可出现运行结果，如图8所示 （图8） 3.多个源文件的编译运行 以上是运行单个源文件的情况，但是在程序设计时，往往是由几个人各自独立编写不同的程序，显然这些程序是不能写在一起进行编译的，这时就需要建立项目工作区来完成几个独立程序的编译，具体方法如下。 首先建立两个文本文件，分别命名为“file1.c”和“file.c”，分别在两个文件中输入如下两个源代码，然后保存。 源代码1： #include Android 4.2源码的下载和编译环境的安装及源码的编译Google于2012.11.14发布了Android4.2的源码，下面把本人在ubuntu10.04 的64位 系统上下载源码，和编译源码做个记录备份，也供有需要的人参考，若是在下载编译安装Android源代码遇到问题，可加QQ群交流: 217706590,难免有错，敬请见谅，还忘勿吝啬指出。 源代码下载、编译环境安装、源代码编译和运行模拟器的可能出现的一些错误在本文最后一章节，若出现类似错误，可以参考。 1、源码的下载 源代码的下载，首先需要安装以下软件：curl 和git-core 1.1安装curl： 在终端中执行：sudo apt-get install curl 1.2安装git-core 1.2．1在用户目录下新建bin文件 在终端中执行：mkdir ~/bin 将~/bin添加环境变量，作用是：要将git软件下载安装在此目录，在别的目录运行可能会找不到此软件，所以要添加到环境变量中 在终端中执行：PA TH=~/bin:$PATH 1.2.2安装git-core 在终端中执行：curl https://https://www.wendangku.net/doc/6e10996502.html,/dl/googlesource/git-repo/repo§> ~/bin/repo 给repo执行权限：chmod a+x ~/bin/repo 1.3 下载源代码 1.3．1进入要源代码将要保存的目录 如我的源代码保存在：、/opt/android/src 在终端中执行：cd /opt/android/src 进入到src目录中 1.3.2 获取repo最新的配置 repo init -u https://https://www.wendangku.net/doc/6e10996502.html,/platform/manifest§ 若是执行错误则用以下命令： ~/bin/repo init -u https://https://www.wendangku.net/doc/6e10996502.html,/platform/manifest§ 1.3.3 下载源代码 对于下载不同版本的android，指定一个manifest分支（即只指明android对应的版 1. 2.编译步骤 (1)jdk安装和部署 1.安装jdk cd /home/lly/下载/hadoop/ rpm –ivhjdk-8u101-linux-x64.rpm 2.添加环境变量 $sudo vim /etc/profile 3.加入如下内容 export JAVA_HOME=/usr/java/jdk1.8.0_101 export JRE_HOME=$JAVA_HOME/jre export CLASSPATH=.:$JAVA_HOME/lib:$JER_HOME/lib:$CLASSPATH export PATH=$JAVA_HOME/bin:$JER_HOME/bin:$PATH 按”esc” :w :q 4.立刻应用改变 $sudo source /etc/profile 5.测试 java –version java version "1.8.0_101" Java(TM) SE Runtime Environment (build 1.8.0_101-b13) Java HotSpot(TM) 64-Bit Server VM (build 25.101-b13, mixed mode) (2)maven安装和部署 1.解压 cd /home/lly/下载/hadoop/ tarzxvfapache-maven-3.3.9-bin.tar.gz -C /usr/soft 2.添加环境变量 $sudo vim /etc/profile 3.加入如下内容 export MAVEN_HOME=/usr/soft/apache-maven-3.3.3 export PATH=.:$PATH:$JAVA_HOME/bin:$MAVEN_HOME/bin 按”esc” :w :q 4.立刻应用改变 $sudo source /etc/profile 5.测试 mvn -version Apache Maven 3.3.9 (bb52d8502b132ec0a5a3f4c09453c07478323dc5; 2015-11-11T00:41:47+08:00) Maven home: /usr/soft/apache-maven-3.3.9 Java version: 1.8.0_101, vendor: Oracle Corporation Java home: /usr/java/jdk1.8.0_101/jre (3)依赖安装 1.输入命令 $sudoyum install g++ autoconfautomakelibtoolcmakezlib1g-dev pkg-configlibssl-de (4)安装cmake 1.解压 cd /home/lly/下载/hadoop/ tarzxvfcmake-3.6.2.tar.gz -C /usr/soft 2.安装 cd/usr/soft/cmake-3.6.2 ./bootstrap make make install 3.测试 cmake–version (5)安装protobuf 1.解压 cd /home/lly/下载/hadoop/ tarzxvfprotobuf-2.5.0.tar.gz -C /usr/soft 2.安装 cd/usr/soft/protobuf-2.5.0 ./configure --prefix=/usr/soft/protobuf-2.5.0 make Turbo C程序设计的基本步骤及如何编译、调试和运行源程序 本节主要介绍Turbo C程序设计的基本步骤及如何编译、调试和运行源程序。并给出Turbo C的常用编辑命令。最后介绍Turbo C编译、连接和运行时的常见错误。 一、Turbo C程序设计基本步骤 程序设计方法包括三个基本步骤： 第一步：分析问题。 第二步：画出程序的基本轮廓。 第三步：实现该程序。 3a.编写程序 3b.测试和调试程序 3c.提供数据打印结果 下面，我们来说明每一步的具体细节。 第一步：分析问题 在这一步，你必须： a. 作为解决问题的一种方法，确定要产生的数据（输出）。作为这一子步的一部分你应定义表示输出的变量。 b. 确定需产生输出的数据（称为输入），作为这一子步的一部分，你应定义表示输入的变量。 c. 研制一种算法，从有限步的输入中获取输出。这种算法定义为结构化的顺序操作，以便在有限步解决问题。就数字问题而言，这种算法包括获取输出的计 Word文档资料 算，但对非数字问题来说，这种算法包括许多文本和图象处理操作。 第二步：画出程序的基本轮廓 在这一步，你要用一些句子（伪代码）来画出程序的基本轮廓。每个句子对应一个简单的程序操作。对一个简单的程序来说，通过列出程序顺序执行的动作，便可直接产生伪代码。然而，对复杂一些的程序来说，则需要将大致过程有条理地进行组织。对此，应使用自上而下的设计方法。 当使用自上而下的设计方法时，你要把程序分割成几段来完成。列出每段要实现的任务，程序的轮廓也就有了，这称之为主模块。当一项任务列在主模块时，仅用其名加以标识，并未指出该任务将如何完成。这方面的容留给程序设计的下一阶段来讨论。将程序分为几项任务只是对程序的初步设计。整个程序设计归结为下图所示的流程图1. 0 1 1主模块 1 I 1 1 I 输入数据I 1主模块I I计算购房所需的金额I 1 I I计算装修所需的金额I 1任务1I I计算总金额I 1任务2I I输出计算结果I 1任务3I I I 1任务4I 1 ---------------- 1 -------------------- 1 I I I——1II——1II——1II1II——1I 1 ---------------------- 1 I输入数据II购房额?? II装修额..I I总额..I I输出 Word文档资料 Ubuntu下编译Android源码全过程（转） 源码, 编译, Ubuntu, Android 一、获取Android源代码 Git是LinuxTorvalds（Linux之父）为了帮助管理Linux内核开发而开发的一个开放源码的分布式版本控制软件，它不同于Subversion、CVS这样的集中式版本控制系统。在集中式版本控制系统中只有一个仓库（Repository），许多个工作目录（WorkingCopy），而在Git这样的分布式版本控制系统中（其他主要的分布式版本控制系统还有BitKeeper、Mercurial、GNUArch、Bazaar、Darcs、SVK、Monotone等），每一个工作目录都包含一个完整仓库，它们支持离线工作，本地提交可以稍后提交到服务器上。 因为Android是由Kernel、Dalvik、Bionic、Prebuilt、build等多个项目组成，如果我们分别使用Git来逐个获取显得很麻烦，所以Android项目编写了一个名为Repo的Python 的脚本来统一管理这些项目的仓库，使得项目的获取更加简单。 在Ubuntu 8.04上安装Git只需要设定正确的更新源，然后使用apt-get就可以了，apt-get 是一条Linux命令，主要用于自动从互联网的软件仓库中搜索、安装、升级、卸载软件或 操作系统。 apt-get命令一般需要root权限执行，所以一般跟着sudo命令。 sudo apt-get install git-core curl 这条命令会从互联网的软件仓库中安装git-core和curl。 其中curl是一个利用URL语法在命令行方式下工作的文件传输工具，它支持很多协议，包括FTP、FTPS、HTTP、HTTPS、TELENT等，我们需要安装它从网络上获取Repo脚本文件。 curl https://www.wendangku.net/doc/6e10996502.html,/repo >~/bin/repo 这句命令会下载repo脚本文件到当前主目录的/bin目录下，并保存在文件repo中。 最后我们需要给repo文件可执行权限 交叉编译与调试方法 一、交叉编译 1. 建立工作目录 2. 编写源代码 3. 编写makefile文件 4. 编译应用程序 #arm-linux-gcc -g hello.c -o hello 5. 启动NSF，挂载共享文件目录 将光盘中的gdbserver与gdb程序拷贝到共享目录 二、调试步骤 1、在Target Board开启gdbserver 进入共享目录 #gdbserver 注意的是要用“c”来执行命令，不能用“r”。因为程序已经在Target Board上面由gdbserver 启动了。结果输出是在Target Board端，用超级终端查看。 4. 交叉调试 (gdb)list (gdb)break func (gdb)break 22 (gdb)info br (gdb)c (这里不能用run) (gdb) n (gdb) p result (gdb) finish (跳出func 函数) (gdb) next (gdb) quit 建立连接后进行gdb 远程调试和gdb 本地调试方法相同 CEGUI 0.7.6 源码配置编译详细过程 （YangJing@南京20120314） 1.我的开发环境 操作系统：Vista Ultimate 32bit中文 编译环境：VS2010旗舰版中文 DXSDK: Microsoft DirectX SDK (June 2010) OGRE版本：1.7.4，直接用的二进制版本 2.下载CEGUI及依赖包源码 下载源码分为2部分，一部分是CEGUI本身的源码，另一部分是编译源码需要的依赖项dependencies。依赖项和源码版本有大致的对应关系，如CEGUI-DEPS-0.7.x-r3-vc10，表示该依赖项包适合于CEGUI 0.7.x（当然也适合于CEGUI0.7.6），vc10编译器，r3是依赖项资源包的版本。下载地址自己找吧。 下载后这个样子： 然后解压，源码解压后，是这个样子： 那个dependencies目录是加了依赖包后才出现的。依赖包解压后的样子： 把这里的dependencies目录拷贝到上面源码包内就可以了。注意相对位置别弄错了。 3.配置过程 目录下有个build_vs2008.bat文件，该文件运行后可以生成CEGUI.sln。还有其它版本的VS2003,VD2005，但是没有VS2010的。我的做法是来个VS2008，然后用VS2010打开，会有个自动升级的过程，就得到2010版的.sln了。 在cmd命令下，目录切换到premake目录，然后运行build_vs2008.bat，就得到CEGUI.sln了。这样，打开解决方案后，发现没有CEGUIOgreRenderer工程，而我要在OGRE应用中使用CEGUI（CEGUIOgreRenderer.lib和CEGUIOgreRenderer.dll），所以这样还不行。 打开build_vs2008.bat，看到： premake --file cegui.lua --target vs2008 说明用了cegui.lua。打开cegui.lua，看到： dofile("config.lua") 等等，莫非有什么配置项在config.lua内，打开config.lua 看到： 红色箭头这一项，本来是false，默认不生成CEGUIOgreRenderer工程，我该为true,然后再运行build_vs2008.bat，在新生成的CEGUI.sln中看到CEGUIOgreRenderer工程了。其它的Renderers也可以在这里找到。我又要了个CEGUIDirect3D10Renderer模块。 然后我就编译整个CEGUI解决方案。发现很多问题： 附录一实验报告样式 《编译原理》实验报告 实验2 简单词法分析 姓名陈婷婷学号1009050121 班级计科1001班 时间：2012/4/5 地点:文波 同组人：无 指导教师：朱少林 实验目的 通过设计调试词法分析程序，实现从源程序中分出各种单词的方法；加深对课堂教学的理解；提高词法分析方法的实践能力。掌握从源程序文件中读取有效字符的方法和产生源程序的内部表示文件的方法；掌握词法分析的实现方法；上机调试编出的词法分析程序。 实验内容 ⑴掌握从源程序文件中读取有效字符的方法和产生源程序的内部表示文件的方法。 ⑵掌握词法分析的实现方法。 ⑶上机调试编出的词法分析程序。 ⑷为简单起见，假设编译语言为具有下特征的C_minus。该词法分析器要求至少能够识别C_minus中的以下几类单词： a．关键字：else if int return void while共6个，所有的关键字都是保留字，并且必须是小写； b．标识符：识别与C语言词法规定相一致的标识符，通过下列正则表达式定义：ID = letter (letter | digit)*； c．常数：NUM=(+ | - |ε)digit digit*(.digit digit* |ε)(e(+ | - |ε) digit digit* |ε)，letter = a|..|z|A|..|Z|，digit = 0|..|9，包括整数，如123, -123, +123等；小数，如123.45, +123.45, -123.45；科学计数法表示的常数，如+1.23e3，-2.3e-9； d．专用符号：+ - * / < <= > >= == != = ; , ( ) [ ] { } /* */； 环境 Linux版本： Ubuntu 11.04（可由 10.10的版本进行升级）64位系统 GCC版本： gcc version 4.5.2 Java版本： java version " 1.6.0_26" 下载android源码前注意： 1、保证Ubuntu系统中的容量在80G左右，以保证足够的空间来存放android源码以及编译后的相关文件。 联网方法： 采用拨号进行连接。相关操作步骤如下所示： 1、虚拟机设置硬件网络适配器网络连接桥接 2、启动Ubuntu系统，打开终端（在普通用户下），输入相关命令如下： $ pppoeconf//打开后输入上网账号跟密码，确认保存 $ sudo pon dsl-provider//上网连接命令 经过这两个步骤后就可以进行上网了。 Android源码编译所依赖的tools 01.$ sudo apt-get update 02.$ sudo apt-get -y install git-core 03.$ sudo apt-get -y install gnupg 04.$ sudo apt-get -y install sun-java6-jdk flex 05.$ sudo apt-get -y install bison 06.$ sudo apt-get -y install gperf 07.$ sudo apt-get -y install libsdl-dev 08.$ sudo apt-get -y install libesd0-dev 09.$ sudo apt-get -y install libwxgtk 2.6-dev 10.$ sudo apt-get -y install build-essential 11.$ sudo apt-get -y install zip 12.$ sudo apt-get -y install curl 13.$ sudo apt-get -y install libncurses5-dev 14.$ sudo apt-get -y install zlib1g-dev 15.$ sudo apt-get -y install valgrind 注意： （如果是32bit的系统的话，则要更改几个Android.mk文件）01./external/clearsilver/cgi/Android.mk C源程序调试方法： 所谓源程序调试是指对程序的查错和排错，一般应经过以下几个步骤： 1进行静态检查 写好一个程序后，不要匆忙用编译器编译，应对写好的源程序进行人工检查，这一步是十分重要的，它能发现程序设计人员由于疏忽而造成的大多错误。为了减少编程错误，在编写程序中应力求做到以下几点： ①应当采用结构化程序方法编程，以增加可读性。 ②应尽可能多加注释，以帮助理解每段程序的作用。 ③在编写复杂的程序时，不要将全部的语句都写在main函数中，而要多利 用函数，用一个函数来实现单独的功能，既易于阅读也便于调试。各函数之间除了用参数传递数据这一渠道外，能够不用其他的渠道就尽量不用，数据间应尽量减少耦合的关系。 2、上机动态检查调试， 根据编译器提示的语法错误，提出编译器提示的全部错误（error）并一一改正，直到通过编译，生成下载文件或调试文件，还应该仔细检查编译器的警告（warning）信息，确认所有的警告信息并不会影响编译结果的正确性。有时，编译器的错误提示并非正确，而且出错的情况繁多且各种错误相互关联，因此要善于分析，找出真正的错误。 3、 Studio环境中进行硬件仿真或软件仿真。 测试的目的是为了测试软硬件能否在各处复杂的情况下正常工作，在测试时应当尽可能地将程序流程中的各分支和各种极限情况都测试一次，程序运行结果不对，大多属于逻辑错误，应将源程序与流程图仔细对照，是很容易发现错误的。 软件思想：本系统主要是用Mega 16主控单片机，控制液晶显示，输入键盘和电机的运行，Mega 16单片机根据键盘输入指令，运行相应的程序。当选择学习示教程序时，就是运用键盘控制电机的运行，然后记录电机运行的相关速度和最终的坐标到相应的寄存器，并在液晶显示器中显示学习示教程序运行状态，使用户更好的进行电机设置和了解电机的运行状态。 Android 源码编译调试流程 by mengke 1 编译流程 sudo apt-get install build-essential sudo apt-get install make sudo apt-get install gcc sudo apt-get install g++ sudo apt-get install libc6-dev sudo apt-get install patch sudo apt-get install texinfo sudo apt-get install libncurses-dev sudo apt-get install git-core gnupg sudo apt-get install flex bison gperf libsdl-dev libesd0-dev libwxgtk2.6-dev build-essential zip curl sudo apt-get install ncurses-dev sudo apt-get install zlib1g-dev sudo apt-get install valgrind sudo apt-get install python2.5 安装java环境 sudo apt-get install sun-java6-jre sun-java6-plugin sun-java6-fonts sun-java6-jdk sudo apt-get install sun-java5-jdk （ubuntu 910 估计会有一些问题） （注：官方文档说如果用sun-java6-jdk可出问题，得要用sun-java5-jdk。经测试发现，如果仅仅make（make不包括make sdk），用sun-java6-jdk是没有问题的。而make sdk，就会有问题，严格来说是在make doc出问题，它需要的javadoc版本为1.5。 因此，我们安装完sun-java6-jdk后最好再安装sun-java5-jdk，或者只安装sun-java5-jdk。这里sun-java6-jdk和sun-java5-jdk都安装，并只修改javadoc.1.gz和javadoc。因为只有这两个是make sdk用到的。这样的话，除了javadoc工具是用1.5版本，其它均用1.6版本： sudo apt-get install sun-java5-jdk） cd /etc/alternatives sudo rm javadoc.1.gz sudo ln -s /usr/lib/jvm/java-1.5.0-sun/man/man1/javadoc.1.gz javadoc.1.gz sudo rm javadoc sudo ln -s /usr/lib/jvm/java-1.5.0-sun/bin/javadoc javadoc 假设源代码的目录为mydroid root@mk-desktop:~/mydroid# ls Makefile build development frameworks out sdk bionic cts device hardware packages system bootable dalvik external ndk prebuilt vendor 《编译原理》实验报告 实验1 查填符号表 姓名学号班级计科1001班 时间：2012/3/22 地点:文波 同组人：无 指导教师：朱少林 实验目的 1、运用所学知识，选择语言、选择算法（数据结构），编程实现符号表管理程序。 2、熟悉编译过程，训练编写程序的能力，为后续实验积累经验。 实验内容 1、运用所学知识，编程实现符号表管理程序。读出源程序中与C语言词法规定相一致的标识符，并在符号表中进行查找，若存在则输出该标识符及其编号和位置；否则将其填入符号表，并分配编号，确定位置，输出该标识符。 2、输出标识符表。 实验环境 软件：VC++6.0 实验前准备 1、方案设计： ①准备模拟数据：由于是识别符合c语言规定的标识符，故本实验中使用“测试文件.c” ②写出c语言标识符的正规式定义：letter_→A|B|C|…Z|a|b|…z|_ digit→0|1|…9 id→letter_(letter_|digit)* ③画出不确定的有限自动机 不确定的有限自动机如下： 进行化简： A={1} B={2,3,4,5,9} C={3,4,5,6,8,9} D={3,4,5,7,8,9} 状态letter_ digit A B B C D C C D D C D 进行化简：{A} {B,C,D} 化简后的确定有限自动机如下： ④程序思想：该实验重点是构造识别标识符的函数。程序中，使用的数据结构如下： struct record { char name[20]; }; typedef struct record RECORD; record是用来记录标识符的名字，并且规定标识符的长度最大为20 安卓源码编译 1、编译环境的搭建 操作系统推荐安装64位的ubuntu10.04，其他版本的ubuntu也可以安装，但是可能出现一些莫名其妙的Bug。 系统安装结束之后，还需要安装一些编译源码需要的工具和依赖包。具体内容如下：确认下列软件安装成功并且版本号正确： 1.1 gcc4.4，而不是gcc4.6，如果是4.6，需要安装gcc4.4，命令如下： sudo apt-get install gcc-4.4 sudo apt-get install g++-4.4 cd /usr/bin ls -l gcc* sudo mv gcc gcc.bak sudo ln -s gcc-4.4 gcc ls -l g++* sudo mv g++ g++.bak sudo ln -s g++-4.4 g++ gcc -v g++ -v 1.2 python 2.5-2.7，ubuntu10.04版本，默认的python版本是2.6。 1.3 JDK版本是1.6.0，而不是openJDK， 1.4 安装git sudo apt-get install git-core gnupg 1.5 一些依赖包的安装： Ubuntu系统版本不同，所需要安装的依赖包也不同，具体情况如下所述： u buntu 10.04(64位) $ sudo apt-get install git-core gnupg flex bison gperf build-essential \ zip curl zlib1g-dev libc6-dev lib32ncurses5-dev ia32-libs \ x11proto-core-dev libx11-dev lib32readline5-dev lib32z-dev \ libgl1-mesa-dev g++-multilib mingw32 tofrodos python-markdown \ libxml2-utils xsltproc ubuntu 11.10(64位) 实验二简单程序的编译、链接、调试 一、实验目的 1．熟悉GNU gcc 编译器的使用方法和常用的编译选项 2．熟悉gdb 调试器的各个命令，学习如何有效的调试程序 二、实验内容 1．使用vi 编辑器编写一个简单程序，输出“hello,world!”字符串； 2．用gcc编译器编译所写的程序，练习编译器各个参数的用法； 3．用ld连接器把程序连接成可执行程序，练习连接器各个参数的用法； 4．学习用gdb调试器调试程序，练习使用断点来跟踪程序的运行，查看变量的值或地址，查看寄存器的内容，练习的调试器的各个常用命令； 三、实验指导与步骤 1. 登录Linux，在终端控制台提示符下键入vi启动编辑器（或键入startx启动X Window，通过程序组启动vi编辑器）；也可以使用Gedit 编辑器； 2. 新建一个文件，将文件保存到您的HOME目录，文件扩展名取为*.c，vi编辑器 的编辑格式将自动转换成C格式； 3. 按实验内容要求，编写源代码，将代码输入刚刚新建的文件，保存； 4. 在提示符下键入cd $HOME，看看您的主目录是什么；再键入ls 命令查看有没有 你新建的文件； 5. 在提示符下键入gcc –h，查看gcc编译器的帮助信息； 6. 键入gcc -c –Wall hello.c；如果编译不通过，要理解这些错误，并改正过来；警告 一般无关紧要，但也要重视，警告也可能造成运行时错误；常见编译错误一般有：函数找不到原型，符号不能解释（可能没有定义或没有包含必要的头文件），语法错误：“””，“’”，“}”“)”，“;”等边界符不匹配，函数调用的参数类型不匹配或参数个数不对等等； 6. 如果编译成功，再键入ls命令查看生成了什么文件； 7. 在提示符下键入ld –h，查看ld 连接器的帮助信息。目标文件(*.o) 一般不用单独 连接，所以ld 连接器一般也不单独调用。如果源代码没有任何错误，gcc不带任何编译选项，就可以把源代码编译、连接成可执行程序； 8. 键入gcc –g hello.c –o hello_g，-g选项保证编译后的程序中包含了大量标准调试信 息，以方便调试过程；-o选项指定了输出文件名，如果不指定文件名，默认的输出文件名就是a.out。 9. 键入gdb hello_g，，调试你的程序。主要练习查看变量或寄存器的值，设置断点、 单步跟踪程序运行。 四、实验报告要求 1．实验目的 2．实验内容 gcc编译器、ld连接器的常用选项及基本功能；练习单独调用ld连接器；gdb调试器的基本命令及功能。 3．实验详细步骤 画出从编辑源代码到调试成功的整个过程图；记录自己实际完成的步骤，实验过程中所碰到的难题以及你解决问题的步骤和方法；记录编译程序时编译器报告的错误、解释错误意义和改正方法；记录调试过程调试器报告的错误、解释错误意义和编译实验报告+源代码
Android源码编译
linux实验报告3 Linux上C程序编译,调试和工程文件管理
android源代码下载和编译教程
VC++6.0中如何编译运行及调试C语言程序
Android_4.2_源码下载和编译环境安装及Android_4.2_源码编译
hadoop3.0.0源码编译
TurboC程序设计的基本步骤及如何编译、调试和运行源程序
Ubuntu下编译Android源码全过程
交叉编译与调试!!!
CEGUI0.7.6源码配置编译详细过程
编译原理实验 简单词法分析(含源代码和实验结果)
Ubuntu下Android源码修改、编译及运行、launcher定制
C源程序调试方法
Android 源码编译 流程
编译原理实验-查填符号表(含源代码和运行结果)
安卓系统源码编译
实验二 简单程序的编译、链接、调试
- 编译原理源代码 target=_blank
- Linux下编译安装源码包软件
- Android_4.2_源码下载和编译环境安装及Android_4.2_源码编译
- Android 源码编译 流程
- 如何单独编译Android源代码中的模块
- 编译opencv源代码
- 编译Android源码全过程
- CEGUI0.7.6源码配置编译详细过程
- Linux操作系统下编译并安装源码包
- Linux下源码编译安装详解
- Mangos完全源码编译架设教程
- android源码编译及rom制作
- android源代码下载和编译教程
- Ubuntu下Android源码修改、编译及运行、launcher定制
- 编译原理(PL0编译程序源代码)
- ANDROID 源码编译 流程
- Linux OpenCV2.4.9源码编译安装
- GMesh源码编译设置及工程转换
- Ubuntu下编译Android源码全过程
- 源代码编译和调试共40页文档