linux ios开发环境,Linux下搭建支持IOS http streaming的环境

刺骨的言语ヽ痛彻心扉 2023-01-20 12:53 102阅读 0赞

\#include

\#include "libavformat/avformat.h"

\#include "libavutil/opt.h"

\#define MAX\_LENGTH 1024

typedef struct iputargs\_t\{

char input\[MAX\_LENGTH\];

char output\_prefix\[MAX\_LENGTH\];

char output\[MAX\_LENGTH\];

\}iputargs\_t;

static iputargs\_t input\_args;

//----------------------------------------------------------------

// fopen\_utf8

static FILE \*

fopen\_utf8(const char \* filename, const char \* mode)

FILE \* file = NULL;

file = fopen(filename, mode);

return file;

static AVStream \*add\_output\_stream(AVFormatContext \*output\_format\_context, AVStream \*input\_stream) \{

AVCodecContext \*input\_codec\_context;

AVCodecContext \*output\_codec\_context;

AVStream \*output\_stream;

output\_stream = avformat\_new\_stream(output\_format\_context, NULL);

if (!output\_stream) \{

fprintf(stderr, "Could not allocate stream\\n");

exit(1);

output\_stream->id = 0;

input\_codec\_context = input\_stream->codec;

output\_codec\_context = output\_stream->codec;

output\_codec\_context->codec\_id = input\_codec\_context->codec\_id;

output\_codec\_context->codec\_type = input\_codec\_context->codec\_type;

output\_codec\_context->codec\_tag = input\_codec\_context->codec\_tag;

output\_codec\_context->bit\_rate = input\_codec\_context->bit\_rate;

output\_codec\_context->extradata = input\_codec\_context->extradata;

output\_codec\_context->extradata\_size = input\_codec\_context->extradata\_size;

if(av\_q2d(input\_codec\_context->time\_base) \* input\_codec\_context->ticks\_per\_frame > av\_q2d(input\_stream->time\_base) && av\_q2d(input\_stream->time\_base) < 1.0/1000) \{

output\_codec\_context->time\_base = input\_codec\_context->time\_base;

output\_codec\_context->time\_base.num \*= input\_codec\_context->ticks\_per\_frame;

else \{

output\_codec\_context->time\_base = input\_stream->time\_base;

switch (input\_codec\_context->codec\_type) \{

case AVMEDIA\_TYPE\_AUDIO:

output\_codec\_context->channel\_layout = input\_codec\_context->channel\_layout;

output\_codec\_context->sample\_rate = input\_codec\_context->sample\_rate;

output\_codec\_context->channels = input\_codec\_context->channels;

output\_codec\_context->frame\_size = input\_codec\_context->frame\_size;

if ((input\_codec\_context->block\_align == 1 && input\_codec\_context->codec\_id == CODEC\_ID\_MP3) || input\_codec\_context->codec\_id == CODEC\_ID\_AC3) \{

output\_codec\_context->block\_align = 0;

else \{

output\_codec\_context->block\_align = input\_codec\_context->block\_align;

break;

case AVMEDIA\_TYPE\_VIDEO:

output\_codec\_context->pix\_fmt = input\_codec\_context->pix\_fmt;

output\_codec\_context->width = input\_codec\_context->width;

output\_codec\_context->height = input\_codec\_context->height;

output\_codec\_context->has\_b\_frames = input\_codec\_context->has\_b\_frames;

if (output\_format\_context->oformat->flags & AVFMT\_GLOBALHEADER) \{

output\_codec\_context->flags |= CODEC\_FLAG\_GLOBAL\_HEADER;

break;

default:

break;

return output\_stream;

typedef struct SMSegmentInfo

unsigned int index;

double duration;

char \* filename;

\} TSMSegmentInfo;

typedef struct SMPlaylist

/\* a ring buffer of segments \*/

TSMSegmentInfo \* buffer;

/\* maximum number of segments that can be stored in the ring buffer \*/

unsigned int bufferCapacity;

/\* index of the first segment on the ring buffer \*/

unsigned int first;

/\* how many segments are currently in the ring buffer \*/

unsigned int count;

/\* shortcuts \*/

unsigned int targetDuration;

char \* httpPrefix;

/\* playlist file used for non-live streaming \*/

FILE \* file;

\} TSMPlaylist;

static char \*

duplicateString(const char \* str)

/\* unfortunately strdup isn't always available \*/

size\_t strSize = strlen(str) + 1;

char \* copy = (char \*) malloc(strSize);

memcpy(copy, str, strSize);

return copy;

static TSMPlaylist \*

createPlaylist(const unsigned int max\_segments,

const unsigned int target\_segment\_duration,

const char \* http\_prefix)

TSMPlaylist \* playlist = (TSMPlaylist \*) malloc(sizeof(TSMPlaylist));

memset(playlist, 0, sizeof(TSMPlaylist));

if (max\_segments)

playlist->buffer = (TSMSegmentInfo \*) malloc(sizeof(TSMSegmentInfo) \*

max\_segments);

playlist->bufferCapacity = max\_segments;

playlist->targetDuration = target\_segment\_duration;

playlist->httpPrefix = duplicateString(http\_prefix);

return playlist;

static void

updateLivePlaylist(TSMPlaylist \* playlist,

const char \* playlistFileName,

const char \* outputFileName,

const unsigned int segmentIndex,

const double segmentDuration)

unsigned int bufferIndex = 0;

TSMSegmentInfo \* nextSegment = NULL;

TSMSegmentInfo removeMe;

memset(&removeMe, 0, sizeof(removeMe));

assert(!playlist->file);

if (playlist->count == playlist->bufferCapacity)

/\* keep track of the segment that should be removed \*/

removeMe = playlist->buffer\[playlist->first\];

/\* make room for the new segment \*/

playlist->first++;

playlist->first %= playlist->bufferCapacity;

else

playlist->count++;

/\* store the new segment info \*/

bufferIndex = ((playlist->first + playlist->count - 1) %

playlist->bufferCapacity);

nextSegment = &playlist->buffer\[bufferIndex\];

nextSegment->filename = duplicateString(outputFileName);

nextSegment->duration = segmentDuration;

nextSegment->index = segmentIndex;

/\* live streaming -- write full playlist from scratch \*/

playlist->file = fopen\_utf8(playlistFileName, "w+b");

if (playlist->file)

unsigned int i, j;

const TSMSegmentInfo \* first = &playlist->buffer\[playlist->first\];

char tmp\[1024\] = \{ 0 \};

snprintf(tmp,

sizeof(tmp),

"\#EXTM3U\\n"

"\#EXT-X-TARGETDURATION:%u\\n"

"\#EXT-X-MEDIA-SEQUENCE:%u\\n",

playlist->targetDuration,

first->index);

fwrite(tmp, strlen(tmp), 1, playlist->file);

for ( i = 0; i < playlist->count; i++)

j = ((playlist->first + i) %

playlist->bufferCapacity);

const TSMSegmentInfo \* segment = &playlist->buffer\[j\];

snprintf(tmp,

sizeof(tmp),

"\#EXTINF:%u,\\n%s%s\\n",

(int)(segment->duration + 0.5),

playlist->httpPrefix,

segment->filename);

fwrite(tmp, strlen(tmp), 1, playlist->file);

// snprintf(tmp, sizeof(tmp), "\#EXT-X-ENDLIST\\n");

// fwrite(tmp, strlen(tmp), 1, playlist->file);

fclose(playlist->file);

playlist->file = NULL;

else

fprintf(stderr,

"Could not open m3u8 index file (%s), "

"no index file will be created\\n",

playlistFileName);

if (removeMe.filename)

/\* remove the oldest segment file \*/

remove(removeMe.filename);

free(removeMe.filename);

static void

updatePlaylist(TSMPlaylist \* playlist,

const char \* playlistFileName,

const char \* segmentFileName,

const unsigned int segmentIndex,

const int segmentDuration)

if (playlist->bufferCapacity > 0)

/\* create a live streaming playlist \*/

updateLivePlaylist(playlist,

playlistFileName,

segmentFileName,

segmentIndex,

segmentDuration);

else

/\* append to the existing playlist \*/

char tmp\[1024\] = \{ 0 \};

if (!playlist->file)

playlist->file = fopen\_utf8(playlistFileName, "w+b");

snprintf(tmp,

sizeof(tmp),

"\#EXTM3U\\n"

"\#EXT-X-TARGETDURATION:%u\\n",

playlist->targetDuration);

fwrite(tmp, strlen(tmp), 1, playlist->file);

if (!playlist->file)

fprintf(stderr,

"Could not open m3u8 index file (%s), "

"no index file will be created\\n",

playlistFileName);

snprintf(tmp,

sizeof(tmp),

"\#EXTINF:%u,\\n%s%s\\n",

segmentDuration,

playlist->httpPrefix,

segmentFileName);

fwrite(tmp, strlen(tmp), 1, playlist->file);

fflush(playlist->file);

static void

closePlaylist(TSMPlaylist \* playlist)

if (playlist->file)

/\* append to the existing playlist \*/

char tmp\[1024\] = \{ 0 \};

snprintf(tmp, sizeof(tmp), "\#EXT-X-ENDLIST\\n");

fwrite(tmp, strlen(tmp), 1, playlist->file);

fclose(playlist->file);

playlist->file = NULL;

static void

releasePlaylist(TSMPlaylist \*\* playlistRef)

TSMPlaylist \* playlist = \*playlistRef;

closePlaylist(playlist);

unsigned int i ;

for (i = 0; i < playlist->bufferCapacity; i++)

TSMSegmentInfo \* segmentInfo = &playlist->buffer\[i\];

if (segmentInfo->filename)

free(segmentInfo->filename);

free(playlist->buffer);

free(playlist->httpPrefix);

free(playlist);

\*playlistRef = NULL;

typedef struct SMPacketLink

/\* packet start time in seconds \*/

double timeStamp;

/\* the packet \*/

AVPacket packet;

/\* a link to the next packet \*/

struct SMPacketLink \* next;

\} TSMPacketLink;

typedef struct SMPacketList

TSMPacketLink \* head;

TSMPacketLink \* tail;

unsigned int size;

\} TSMPacketList;

typedef struct SMStreamLace

TSMPacketList \*\* streams;

unsigned int numStreams;

\} TSMStreamLace;

static TSMPacketLink \*

createLink(const AVPacket \* packet, double timeStamp)

TSMPacketLink \* link = (TSMPacketLink \*) malloc(sizeof(TSMPacketLink));

link->timeStamp = timeStamp;

link->next = NULL;

memcpy(&link->packet, packet, sizeof(AVPacket));

return link;

static void

fifoPush(TSMPacketList \* packets, const AVPacket \* packet, double timeStamp)

TSMPacketLink \* link = createLink(packet, timeStamp);

if (!packets->head)

assert(!packets->tail);

assert(!packets->size);

packets->head = link;

packets->tail = link;

packets->size = 1;

else

/\* attach at the tail \*/

assert(packets->size > 0);

packets->tail->next = link;

packets->tail = link;

packets->size++;

static int

fifoPop(TSMPacketList \* packets, AVPacket \* packet)

TSMPacketLink \* link = packets->head;

if (!link)

return 0;

memcpy(packet, &link->packet, sizeof(AVPacket));

packets->head = link->next;

packets->size--;

if (!packets->head)

packets->tail = NULL;

free(link);

return 1;

static TSMPacketList \*

createPacketList()

TSMPacketList \* packets = (TSMPacketList \*)malloc(sizeof(TSMPacketList));

memset(packets, 0, sizeof(TSMPacketList));

return packets;

static TSMStreamLace \*

createStreamLace(unsigned int numStreams)

unsigned int i;

TSMStreamLace \* lace = (TSMStreamLace \*)malloc(sizeof(TSMStreamLace));

lace->streams = (TSMPacketList \*\*)malloc(sizeof(TSMPacketList \*) \* numStreams);

for ( i = 0; i < numStreams; i++)

lace->streams\[i\] = createPacketList();

lace->numStreams = numStreams;

return lace;

static void

insertPacket(TSMStreamLace \* lace, const AVPacket \* packet, double timeStamp)

fifoPush(lace->streams\[packet->stream\_index\], packet, timeStamp);

static TSMPacketList \*

chooseNextStream(TSMStreamLace \* lace)

/\* improve lacing so that that audio/video packets that should be

together do not get stuck into separate segments. \*/

TSMPacketList \* nextStream = NULL;

double earliestTimeStamp = DBL\_MAX;

unsigned int i;

for (i = 0; i < lace->numStreams; i++)

TSMPacketList \* stream = lace->streams\[i\];

if (stream->size && stream->head->timeStamp < earliestTimeStamp)

nextStream = stream;

earliestTimeStamp = stream->head->timeStamp;

return nextStream;

static int

removePacket(TSMStreamLace \* lace, AVPacket \* packet)

TSMPacketList \* stream = chooseNextStream(lace);

if (!stream)

return 0;

return fifoPop(stream, packet);

static unsigned int

countPackets(const TSMStreamLace \* lace)

unsigned int numPackets = 0;

unsigned int i;

for ( i = 0; i < lace->numStreams; i++)

const TSMPacketList \* stream = lace->streams\[i\];

numPackets += stream->size;

return numPackets;

static void

removeAllPackets(TSMStreamLace \* lace)

unsigned int i;

AVPacket packet;

for ( i = 0; i < lace->numStreams; i++)

TSMPacketList \* stream = lace->streams\[i\];

while (stream->size)

fifoPop(stream, &packet);

av\_free\_packet(&packet);

static int

loglevel(const char\* arg)

const struct \{ const char \*name; int level; \} log\_levels\[\] = \{

\{ "quiet" , AV\_LOG\_QUIET \},

\{ "panic" , AV\_LOG\_PANIC \},

\{ "fatal" , AV\_LOG\_FATAL \},

\{ "error" , AV\_LOG\_ERROR \},

\{ "warning", AV\_LOG\_WARNING \},

\{ "info" , AV\_LOG\_INFO \},

\{ "verbose", AV\_LOG\_VERBOSE \},

\{ "debug" , AV\_LOG\_DEBUG \},

\};

int i;

for (i = 0; i < FF\_ARRAY\_ELEMS(log\_levels); i++) \{

if (!strcmp(log\_levels\[i\].name, arg)) \{

av\_log\_set\_level(log\_levels\[i\].level);

return 0;

return 1;

//----------------------------------------------------------------

// usage3

static void usage3(char \*\* argv, const char \* message, const char \* details)

if (message)

fprintf(stderr, "ERROR: %s%s\\n\\n", message, details);

fprintf(stderr,

"USAGE: %s "

"-i input-MPEG-TS-file "

"-d seconds-per-segment "

"\[-o segment-file-prefix\] "

"-x output-playlist-m3u8 "

"\[-p http-prefix\] "

"\[-w max-live-segments\] "

"\[-P pid-file\] "

"\[--watch-for-kill-file\] "

"\[--strict-segment-duration\] "

"\[--avformat-option opt value\] "

"\[--loglevel level\] "

"\\n\\n",

argv\[0\]);

fprintf(stderr,

"Compiled by Daniel Espendiller - \\n"

"build on %s %s with %s\\n\\n"

"Took some code from:\\n"

" - source:\\n"

" - iStreamdev:http://projects.vdr-developer.org/git/?p=istreamdev.git;a=tree;f=segmenter;hb=HEAD\\n"

" - live\_segmenter:\\n",

\_\_DATE\_\_,

\_\_TIME\_\_,

\_\_VERSION\_\_);

exit(1);

//----------------------------------------------------------------

// usage

static void usage(char \*\* argv, const char \* message)

\{ usage3(argv, message, ""); \}

//----------------------------------------------------------------

// main\_utf8

int main\_utf8(int argc, char \*\*argv)

double target\_segment\_duration = 0.0;

char \*segment\_duration\_check = NULL;

const char \*playlist\_filename = NULL;

const char \*http\_prefix = "";

long max\_tsfiles = 0;

char \*max\_tsfiles\_check = NULL;

double prev\_segment\_time = 0.0;

double segment\_duration = 0.0;

unsigned int output\_index = 0;

const AVClass \*fc = avformat\_get\_class();

AVDictionary \*format\_opts = NULL;

AVOutputFormat \*ofmt = NULL;

AVFormatContext \*ic = NULL;

AVFormatContext \*oc = NULL;

AVStream \*video\_st = NULL;

AVStream \*audio\_st = NULL;

AVCodec \*codec = NULL;

char \*pid\_filename = NULL;

int video\_index = -1;

int audio\_index = -1;

int kill\_file = 0;

int decode\_done = 0;

int ret = 0;

int i = 0;

TSMStreamLace \* streamLace = NULL;

TSMPlaylist \* playlist = NULL;

const double segment\_duration\_error\_tolerance = 0.05;

double extra\_duration\_needed = 0;

int strict\_segment\_duration = 0;

av\_log\_set\_level(AV\_LOG\_INFO);

for (i = 1; i < argc; i++)

if (strcmp(argv\[i\], "-i") == 0)

if ((argc - i) <= 1)

usage(argv, "could not parse -i parameter");

i++;

strcpy(input\_args.input, argv\[i\]);

else if (strcmp(argv\[i\], "-o") == 0)

if ((argc - i) <= 1)

usage(argv, "could not parse -i parameter");

i++;

strcpy(input\_args.output\_prefix, argv\[i\]);

else if (strcmp(argv\[i\], "-d") == 0)

if ((argc - i) <= 1) usage(argv, "could not parse -d parameter");

i++;

target\_segment\_duration = strtod(argv\[i\], &segment\_duration\_check);

if (segment\_duration\_check == argv\[i\] ||

target\_segment\_duration == HUGE\_VAL ||

target\_segment\_duration == -HUGE\_VAL)

usage3(argv, "invalid segment duration: ", argv\[i\]);

else if (strcmp(argv\[i\], "-x") == 0)

if ((argc - i) <= 1) usage(argv, "could not parse -x parameter");

i++;

playlist\_filename = argv\[i\];

else if (strcmp(argv\[i\], "-p") == 0)

if ((argc - i) <= 1) usage(argv, "could not parse -p parameter");

i++;

http\_prefix = argv\[i\];

else if (strcmp(argv\[i\], "-w") == 0)

if ((argc - i) <= 1) usage(argv, "could not parse -w parameter");

i++;

max\_tsfiles = strtol(argv\[i\], &max\_tsfiles\_check, 10);

if (max\_tsfiles\_check == argv\[i\] ||

max\_tsfiles < 0 ||

max\_tsfiles >= INT\_MAX)

usage3(argv, "invalid live stream max window size: ", argv\[i\]);

if (!input\_args.input)

usage(argv, "-i input file parameter must be specified");

printf("+++input\_file: %s\\n", input\_args.input);

if (!playlist\_filename)

usage(argv, "-x m3u8 playlist file parameter must be specified");

printf("+++playlist\_filename: %s\\n", playlist\_filename);

if (target\_segment\_duration == 0.0)

usage(argv, "-d segment duration parameter must be specified");

printf("+++target\_segment\_duration: %f\\n", target\_segment\_duration);

av\_register\_all();

avformat\_network\_init();

if (!strcmp(input\_args.input, "-")) \{

strcpy(input\_args.input, "pipe:");

playlist = createPlaylist(max\_tsfiles,

target\_segment\_duration,

http\_prefix);

if (!playlist)

fprintf(stderr, "Could not allocate space for m3u8 playlist structure\\n");

goto error;

ic = avformat\_alloc\_context();

ret = avformat\_open\_input(&ic, input\_args.input, NULL, NULL);

if (ret != 0) \{

fprintf(stderr, "Could not open input file, make sure it is an mpegts or mp4 file: %d\\n", ret);

goto error;

if (avformat\_find\_stream\_info(ic, NULL) < 0) \{

fprintf(stderr, "Could not read stream information\\n");

goto error;

av\_dump\_format(ic, 0, input\_args.input, 0);

ofmt = av\_guess\_format("mpegts", NULL, NULL);

if (!ofmt) \{

fprintf(stderr, "Could not find MPEG-TS muxer\\n");

goto error;

oc = avformat\_alloc\_context();

if (!oc) \{

fprintf(stderr, "Could not allocated output context\\n");

goto error;

oc->oformat = ofmt;

video\_index = -1;

audio\_index = -1;

for (i = 0; i < ic->nb\_streams && (video\_index < 0 || audio\_index < 0); i++) \{

switch (ic->streams\[i\]->codec->codec\_type) \{

case AVMEDIA\_TYPE\_VIDEO:

video\_index = i;

ic->streams\[i\]->discard = AVDISCARD\_NONE;

video\_st = add\_output\_stream(oc, ic->streams\[i\]);

break;

case AVMEDIA\_TYPE\_AUDIO:

audio\_index = i;

ic->streams\[i\]->discard = AVDISCARD\_NONE;

audio\_st = add\_output\_stream(oc, ic->streams\[i\]);

break;

default:

ic->streams\[i\]->discard = AVDISCARD\_ALL;

break;

av\_dump\_format(oc, 0, input\_args.output\_prefix, 1);

if (video\_index >=0) \{

codec = avcodec\_find\_decoder(video\_st->codec->codec\_id);

if (!codec) \{

fprintf(stderr, "Could not find video decoder, key frames will not be honored\\n");

if (avcodec\_open2(video\_st->codec, codec, NULL) < 0) \{

fprintf(stderr, "Could not open video decoder, key frames will not be honored\\n");

sprintf(input\_args.output, "%s-%u.ts", input\_args.output\_prefix, ++output\_index);

if (avio\_open(&oc->pb, input\_args.output, AVIO\_FLAG\_WRITE) < 0) \{

fprintf(stderr, "Could not open '%s'\\n", input\_args.output);

goto error;

if (avformat\_write\_header(oc, NULL)) \{

fprintf(stderr, "Could not write mpegts header to first output file\\n");

goto error;

prev\_segment\_time = (double)(ic->start\_time) / (double)(AV\_TIME\_BASE);

streamLace = createStreamLace(ic->nb\_streams);

do \{

double segment\_time = 0.0;

AVPacket packet;

double packetStartTime = 0.0;

double packetDuration = 0.0;

if (!decode\_done)

decode\_done = av\_read\_frame(ic, &packet);

if (!decode\_done)

if (packet.stream\_index != video\_index &&

packet.stream\_index != audio\_index)

av\_free\_packet(&packet);

continue;

double timeStamp =

(double)(packet.pts) \*

(double)(ic->streams\[packet.stream\_index\]->time\_base.num) /

(double)(ic->streams\[packet.stream\_index\]->time\_base.den);

if (av\_dup\_packet(&packet) < 0)

fprintf(stderr, "Could not duplicate packet\\n");

av\_free\_packet(&packet);

break;

insertPacket(streamLace, &packet, timeStamp);

if (countPackets(streamLace) < 50 && !decode\_done)

/\* allow the queue to fill up so that the packets can be sorted properly \*/

continue;

if (!removePacket(streamLace, &packet))

if (decode\_done)

/\* the queue is empty, we are done \*/

break;

assert(decode\_done);

continue;

packetStartTime =

(double)(packet.pts) \*

(double)(ic->streams\[packet.stream\_index\]->time\_base.num) /

(double)(ic->streams\[packet.stream\_index\]->time\_base.den);

packetDuration =

(double)(packet.duration) \*

(double)(ic->streams\[packet.stream\_index\]->time\_base.num) /

(double)(ic->streams\[packet.stream\_index\]->time\_base.den);

\#if !defined(NDEBUG) && (defined(DEBUG) || defined(\_DEBUG))

if (av\_log\_get\_level() >= AV\_LOG\_VERBOSE)

fprintf(stderr,

"stream %i, packet \[%f, %f)\\n",

packet.stream\_index,

packetStartTime,

packetStartTime + packetDuration);

\#endif

segment\_duration = packetStartTime + packetDuration - prev\_segment\_time;

// NOTE: segments are supposed to start on a keyframe.

// If the keyframe interval and segment duration do not match

// forcing the segment creation for "better seeking behavior"

// will result in decoding artifacts after seeking or stream switching.

if (packet.stream\_index == video\_index && (packet.flags & AV\_PKT\_FLAG\_KEY || strict\_segment\_duration)) \{

segment\_time = packetStartTime;

else if (video\_index < 0) \{

segment\_time = packetStartTime;

else \{

segment\_time = prev\_segment\_time;

printf("segment time: %f\\n", segment\_time);

if (segment\_time - prev\_segment\_time + segment\_duration\_error\_tolerance >

target\_segment\_duration + extra\_duration\_needed)

avio\_flush(oc->pb);

avio\_close(oc->pb);

// Keep track of accumulated rounding error to account for it in later chunks.

double segment\_duration = segment\_time - prev\_segment\_time;

int rounded\_segment\_duration = (int)(segment\_duration + 0.5);

extra\_duration\_needed += (double)rounded\_segment\_duration - segment\_duration;

updatePlaylist(playlist,

playlist\_filename,

input\_args.output,

output\_index,

rounded\_segment\_duration);

sprintf(input\_args.output, "%s-%u.ts", input\_args.output\_prefix, ++output\_index);

if (avio\_open(&oc->pb, input\_args.output, AVIO\_FLAG\_WRITE) < 0) \{

fprintf(stderr, "Could not open '%s'\\n", input\_args.output);

break;

// close when we find the 'kill' file

if (kill\_file) \{

FILE\* fp = fopen("kill", "rb");

if (fp) \{

fprintf(stderr, "user abort: found kill file\\n");

fclose(fp);

remove("kill");

decode\_done = 1;

removeAllPackets(streamLace);

prev\_segment\_time = segment\_time;

ret = av\_interleaved\_write\_frame(oc, &packet);

if (ret < 0) \{

fprintf(stderr, "Warning: Could not write frame of stream\\n");

else if (ret > 0) \{

fprintf(stderr, "End of stream requested\\n");

av\_free\_packet(&packet);

break;

av\_free\_packet(&packet);

\} while (!decode\_done || countPackets(streamLace) > 0);

av\_write\_trailer(oc);

if (video\_index >= 0) \{

avcodec\_close(video\_st->codec);

for(i = 0; i < oc->nb\_streams; i++) \{

av\_freep(&oc->streams\[i\]->codec);

av\_freep(&oc->streams\[i\]);

avio\_close(oc->pb);

av\_free(oc);

updatePlaylist(playlist,

playlist\_filename,

input\_args.output,

output\_index,

segment\_duration);

closePlaylist(playlist);

releasePlaylist(&playlist);

if (pid\_filename)

remove(pid\_filename);

return 0;

error:

if (pid\_filename)

remove(pid\_filename);

return 1;

int main(int argc, char \*\* argv)

return main\_utf8(argc, argv);

linux ios开发环境,Linux下搭建支持IOS http streaming的环境

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Linux下Python开发环境搭建

相关 Linux搭建开发环境

相关 Linux下搭建Python开发环境部署

相关 Linux下快速搭建php开发环境

相关 windows下搭建Linux开发环境

相关 Linux下搭建Scala开发环境

相关 linux ios开发环境,Linux下搭建支持IOS http streaming的环境

相关 RTEMS linux 下开发环境搭建

相关 iOS越狱开发环境搭建 theos

相关 Linux下搭建Android开发环境