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

刺骨的言语ヽ痛彻心扉 2023-01-20 12:53 133阅读 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下搭建lua开发环境

相关 Linux 下搭建 Scala 开发环境

相关 windows下搭建Linux开发环境

相关 Linux下搭建Scala开发环境

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

相关搭建Flutter-iOS开发环境

相关 RTEMS linux 下开发环境搭建

相关 Linux下搭建Android开发环境