fduop07

fduop07

关注
发信
关注(28)粉丝(399)

Linux下搭建支持IOS http streaming的环境

本环境的搭建旨在测试IOS  http streaming的测试，进一步探求通过此方式支持实时流的可能性。
一、ffmpeg的编译和移植：
./configure --enable-gpl --enable-nonfree --enable-pthreads --enable-libfaac --enable-libmp3lame --enable-libx264
make && make install


这里编译的过程需要安装libfaac， libmp3lame， libx264这三个第三方开源编码库。
二、安装好ffmpeg后，需要准备符合IOS规定的码流，将码流转码成音频为mp3，视频为h264的编码方式，这里需要说明的是，IOS支持1920x1080p，audio和video解码器都是IOS硬件加速当中提供的，因而不需要你对bitrate、schannel、bitrate等进行转换。
ffmpeg -i ~/Videos/1.ts  -f mpegts -acodec libmp3lame -ar 48000 -ab 64k -s 1080x720 -vcodec libx264 sample.ts
获取到符合的码流以后，需要对码流进行segment。
三、Segment
Ios规定的支持http streaming的方式是由一个索引文件（后缀为.m3u8）和相关分段文件决定的，其中m3u8当中的内容如下：
#EXTM3U
#EXT-X-TARGETDURATION:3
#EXTINF:9,
http://192.168.1.13/./index_dentry/video-1.ts
#EXTINF:7,
http://192.168.1.13/./index_dentry/video-2.ts
#EXTINF:7,
http://192.168.1.13/./index_dentry/video-3.ts
#EXTINF:4,
http://192.168.1.13/./index_dentry/video-4.ts
#EXT-X-ENDLIST
其实就是每个index的url的集合：
Segment.c和Makefile在我的附件当中，因为segment.c是基于ffmpeg去开发的，所以需要你把ffmpeg和segment放在平行目录当中（具体看Makefile调用关系）
./live_segmenter –i -o -d -x -p
分配好以后发现segment时间长度不一致，这是为什么呢，因为H264解码的关系，为了保证每一个segment文件都可以正常播放，因而segment文件的第一个视频帧肯定是key_frame（这样的做法有待商榷）。

点击(此处)折叠或打开

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <sys/types.h>
  5. #include <unistd.h>
  6. #include <assert.h>
  7. #include <float.h>
  8. #include <math.h>

  10. #include "libavformat/avformat.h"
  11. #include "libavutil/opt.h"
  12. #define MAX_LENGTH 1024
  13. typedef struct iputargs_t{
  14.     char input[MAX_LENGTH];
  15.     char output_prefix[MAX_LENGTH];
  16.     char output[MAX_LENGTH];

  18. }iputargs_t;

  20. static iputargs_t input_args;

  22. //----------------------------------------------------------------
  23. // fopen_utf8
  24. //
  25. static FILE *
  26. fopen_utf8(const char * filename, const char * mode)
  27. {
  28.     FILE * file = NULL;
  29.     

  31.     file = fopen(filename, mode);
  32.     
  33.     return file;
  34. }


  37. static AVStream *add_output_stream(AVFormatContext *output_format_context, AVStream *input_stream) {
  38.     AVCodecContext *input_codec_context;
  39.     AVCodecContext *output_codec_context;
  40.     AVStream *output_stream;

  42.     output_stream = avformat_new_stream(output_format_context, NULL);
  43.     if (!output_stream) {
  44.         fprintf(stderr, "Could not allocate stream\n");
  45.         exit(1);
  46.     }
  47.     output_stream->id = 0;

  49.     input_codec_context = input_stream->codec;
  50.     output_codec_context = output_stream->codec;

  52.     output_codec_context->codec_id = input_codec_context->codec_id;
  53.     output_codec_context->codec_type = input_codec_context->codec_type;
  54.     output_codec_context->codec_tag = input_codec_context->codec_tag;
  55.     output_codec_context->bit_rate = input_codec_context->bit_rate;
  56.     output_codec_context->extradata = input_codec_context->extradata;
  57.     output_codec_context->extradata_size = input_codec_context->extradata_size;

  59.     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) {
  60.         output_codec_context->time_base = input_codec_context->time_base;
  61.         output_codec_context->time_base.num *= input_codec_context->ticks_per_frame;
  62.     }
  63.     else {
  64.         output_codec_context->time_base = input_stream->time_base;
  65.     }

  67.     switch (input_codec_context->codec_type) {
  68.         case AVMEDIA_TYPE_AUDIO:
  69.             output_codec_context->channel_layout = input_codec_context->channel_layout;
  70.             output_codec_context->sample_rate = input_codec_context->sample_rate;
  71.             output_codec_context->channels = input_codec_context->channels;
  72.             output_codec_context->frame_size = input_codec_context->frame_size;
  73.             if ((input_codec_context->block_align == 1 && input_codec_context->codec_id == CODEC_ID_MP3) || input_codec_context->codec_id == CODEC_ID_AC3) {
  74.                 output_codec_context->block_align = 0;
  75.             }
  76.             else {
  77.                 output_codec_context->block_align = input_codec_context->block_align;
  78.             }
  79.             break;
  80.         case AVMEDIA_TYPE_VIDEO:
  81.             output_codec_context->pix_fmt = input_codec_context->pix_fmt;
  82.             output_codec_context->width = input_codec_context->width;
  83.             output_codec_context->height = input_codec_context->height;
  84.             output_codec_context->has_b_frames = input_codec_context->has_b_frames;

  86.             if (output_format_context->oformat->flags & AVFMT_GLOBALHEADER) {
  87.                 output_codec_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
  88.             }
  89.             break;
  90.     default:
  91.         break;
  92.     }

  94.     return output_stream;
  95. }

  97. typedef struct SMSegmentInfo
  98. {
  99.     unsigned int index;
  100.     double duration;
  101.     char * filename;
  102.   
  103. } TSMSegmentInfo;

  105. typedef struct SMPlaylist
  106. {
  107.     /* a ring buffer of segments */
  108.     TSMSegmentInfo * buffer;

  110.     /* maximum number of segments that can be stored in the ring buffer */
  111.     unsigned int bufferCapacity;

  113.     /* index of the first segment on the ring buffer */
  114.     unsigned int first;
  115.     
  116.     /* how many segments are currently in the ring buffer */
  117.     unsigned int count;

  119.     /* shortcuts */
  120.     unsigned int targetDuration;
  121.     char * httpPrefix;

  123.     /* playlist file used for non-live streaming */
  124.     FILE * file;
  125.   
  126. } TSMPlaylist;

  128. static char *
  129. duplicateString(const char * str)
  130. {
  131.     /* unfortunately strdup isn't always available */
  132.     size_t strSize = strlen(str) + 1;
  133.     char * copy = (char *) malloc(strSize);
  134.     memcpy(copy, str, strSize);
  135.     return copy;
  136. }

  138. static TSMPlaylist *
  139. createPlaylist(const unsigned int max_segments,
  140.                const unsigned int target_segment_duration,
  141.                const char * http_prefix)
  142. {
  143.     TSMPlaylist * playlist = (TSMPlaylist *) malloc(sizeof(TSMPlaylist));
  144.     memset(playlist, 0, sizeof(TSMPlaylist));

  146.     if (max_segments)
  147.     {
  148.         playlist->buffer = (TSMSegmentInfo *) malloc(sizeof(TSMSegmentInfo) *
  149.                                                      max_segments);
  150.     }
  151.     
  152.     playlist->bufferCapacity = max_segments;
  153.     playlist->targetDuration = target_segment_duration;
  154.     playlist->httpPrefix = duplicateString(http_prefix);
  155.     
  156.     return playlist;
  157. }

  159. static void
  160. updateLivePlaylist(TSMPlaylist * playlist,
  161.                    const char * playlistFileName,
  162.                    const char * outputFileName,
  163.                    const unsigned int segmentIndex,
  164.                    const double segmentDuration)
  165. {
  166.     unsigned int bufferIndex = 0;
  167.     TSMSegmentInfo * nextSegment = NULL;
  168.     TSMSegmentInfo removeMe;
  169.     memset(&removeMe, 0, sizeof(removeMe));
  170.     assert(!playlist->file);
  171.     
  172.     if (playlist->count == playlist->bufferCapacity)
  173.     {
  174.         /* keep track of the segment that should be removed */
  175.         removeMe = playlist->buffer[playlist->first];
  176.         
  177.         /* make room for the new segment */
  178.         playlist->first++;
  179.         playlist->first %= playlist->bufferCapacity;
  180.     }
  181.     else
  182.     {
  183.         playlist->count++;
  184.     }

  186.     /* store the new segment info */
  187.     bufferIndex = ((playlist->first + playlist->count - 1) %
  188.                    playlist->bufferCapacity);
  189.     nextSegment = &playlist->buffer[bufferIndex];
  190.     nextSegment->filename = duplicateString(outputFileName);
  191.     nextSegment->duration = segmentDuration;
  192.     nextSegment->index = segmentIndex;
  193.     
  194.     /* live streaming -- write full playlist from scratch */
  195.     playlist->file = fopen_utf8(playlistFileName, "w+b");
  196.     
  197.     if (playlist->file)
  198.     {
  199.         unsigned int i, j;
  200.         const TSMSegmentInfo * first = &playlist->buffer[playlist->first];
  201.         
  202.         char tmp[1024] = { 0 };
  203.         snprintf(tmp,
  204.                  sizeof(tmp),
  205.                  "#EXTM3U\n"
  206.                  "#EXT-X-TARGETDURATION:%u\n"
  207.                  "#EXT-X-MEDIA-SEQUENCE:%u\n",
  208.                  playlist->targetDuration,
  209.                  first->index);
  210.         fwrite(tmp, strlen(tmp), 1, playlist->file);
  211.         
  212.         for ( i = 0; i < playlist->count; i++)
  213.         {
  214.            j = ((playlist->first + i) %
  215.                               playlist->bufferCapacity);
  216.             
  217.             const TSMSegmentInfo * segment = &playlist->buffer[j];
  218.             snprintf(tmp,
  219.                      sizeof(tmp),
  220.                      "#EXTINF:%u,\n%s%s\n",
  221.                      (int)(segment->duration + 0.5),
  222.                      playlist->httpPrefix,
  223.                      segment->filename);
  224.             fwrite(tmp, strlen(tmp), 1, playlist->file);
  225.         }
  226.         
  227.         // snprintf(tmp, sizeof(tmp), "#EXT-X-ENDLIST\n");
  228.         // fwrite(tmp, strlen(tmp), 1, playlist->file);
  229.         
  230.         fclose(playlist->file);
  231.         playlist->file = NULL;
  232.     }
  233.     else
  234.     {
  235.         fprintf(stderr,
  236.                 "Could not open m3u8 index file (%s), "
  237.                 "no index file will be created\n",
  238.                 playlistFileName);
  239.     }
  240.     
  241.     if (removeMe.filename)
  242.     {
  243.         /* remove the oldest segment file */
  244.         remove(removeMe.filename);
  245.         free(removeMe.filename);
  246.     }
  247. }

  249. static void
  250. updatePlaylist(TSMPlaylist * playlist,
  251.                const char * playlistFileName,
  252.                const char * segmentFileName,
  253.                const unsigned int segmentIndex,
  254.                const int segmentDuration)
  255. {
  256.     if (playlist->bufferCapacity > 0)
  257.     {
  258.         /* create a live streaming playlist */
  259.         updateLivePlaylist(playlist,
  260.                            playlistFileName,
  261.                            segmentFileName,
  262.                            segmentIndex,
  263.                            segmentDuration);
  264.     }
  265.     else
  266.     {
  267.         /* append to the existing playlist */
  268.         char tmp[1024] = { 0 };

  270.         if (!playlist->file)
  271.         {
  272.             playlist->file = fopen_utf8(playlistFileName, "w+b");
  273.             snprintf(tmp,
  274.                      sizeof(tmp),
  275.                      "#EXTM3U\n"
  276.                      "#EXT-X-TARGETDURATION:%u\n",
  277.                      playlist->targetDuration);
  278.             fwrite(tmp, strlen(tmp), 1, playlist->file);
  279.         }
  280.         
  281.         if (!playlist->file)
  282.         {
  283.             fprintf(stderr,
  284.                     "Could not open m3u8 index file (%s), "
  285.                     "no index file will be created\n",
  286.                     playlistFileName);
  287.         }
  288.         
  289.         snprintf(tmp,
  290.                  sizeof(tmp),
  291.                  "#EXTINF:%u,\n%s%s\n",
  292.                  segmentDuration,
  293.                  playlist->httpPrefix,
  294.                  segmentFileName);
  295.         fwrite(tmp, strlen(tmp), 1, playlist->file);
  296.         fflush(playlist->file);
  297.     }
  298. }

  300. static void
  301. closePlaylist(TSMPlaylist * playlist)
  302. {
  303.     if (playlist->file)
  304.     {
  305.         /* append to the existing playlist */
  306.         char tmp[1024] = { 0 };
  307.         
  308.         snprintf(tmp, sizeof(tmp), "#EXT-X-ENDLIST\n");
  309.         fwrite(tmp, strlen(tmp), 1, playlist->file);
  310.         
  311.         fclose(playlist->file);
  312.         playlist->file = NULL;
  313.     }
  314. }

  316. static void
  317. releasePlaylist(TSMPlaylist ** playlistRef)
  318. {
  319.     TSMPlaylist * playlist = *playlistRef;
  320.     closePlaylist(playlist);
  321.     unsigned int i ;
  322.     
  323.     for (i = 0; i < playlist->bufferCapacity; i++)
  324.     {
  325.         TSMSegmentInfo * segmentInfo = &playlist->buffer[i];
  326.         if (segmentInfo->filename)
  327.         {
  328.             free(segmentInfo->filename);
  329.         }
  330.     }
  331.     
  332.     free(playlist->buffer);
  333.     free(playlist->httpPrefix);
  334.     free(playlist);
  335.     *playlistRef = NULL;
  336. }
  337.     

  339. typedef struct SMPacketLink
  340. {
  341.     /* packet start time in seconds */
  342.     double timeStamp;

  344.     /* the packet */
  345.     AVPacket packet;

  347.     /* a link to the next packet */
  348.     struct SMPacketLink * next;
  349.     
  350. } TSMPacketLink;

  352. typedef struct SMPacketList
  353. {
  354.     TSMPacketLink * head;
  355.     TSMPacketLink * tail;
  356.     unsigned int size;
  357. } TSMPacketList;

  359. typedef struct SMStreamLace
  360. {
  361.     TSMPacketList ** streams;
  362.     unsigned int numStreams;
  363. } TSMStreamLace;

  365. static TSMPacketLink *
  366. createLink(const AVPacket * packet, double timeStamp)
  367. {
  368.     TSMPacketLink * link = (TSMPacketLink *) malloc(sizeof(TSMPacketLink));
  369.     link->timeStamp = timeStamp;
  370.     link->next = NULL;
  371.     memcpy(&link->packet, packet, sizeof(AVPacket));
  372.     return link;
  373. }

  375. static void
  376. fifoPush(TSMPacketList * packets, const AVPacket * packet, double timeStamp)
  377. {
  378.     TSMPacketLink * link = createLink(packet, timeStamp);
  379.     if (!packets->head)
  380.     {
  381.         assert(!packets->tail);
  382.         assert(!packets->size);
  383.         packets->head = link;
  384.         packets->tail = link;
  385.         packets->size = 1;
  386.     }
  387.     else
  388.     {
  389.         /* attach at the tail */
  390.         assert(packets->size > 0);
  391.         
  392.         packets->tail->next = link;
  393.         packets->tail = link;
  394.         packets->size++;
  395.     }
  396. }

  398. static int
  399. fifoPop(TSMPacketList * packets, AVPacket * packet)
  400. {
  401.     TSMPacketLink * link = packets->head;
  402.     if (!link)
  403.     {
  404.         return 0;
  405.     }
  406.     
  407.     memcpy(packet, &link->packet, sizeof(AVPacket));
  408.     packets->head = link->next;
  409.     packets->size--;
  410.     
  411.     if (!packets->head)
  412.     {
  413.         packets->tail = NULL;
  414.     }
  415.     
  416.     free(link);
  417.     return 1;
  418. }

  420. static TSMPacketList *
  421. createPacketList()
  422. {
  423.     TSMPacketList * packets = (TSMPacketList *)malloc(sizeof(TSMPacketList));
  424.     memset(packets, 0, sizeof(TSMPacketList));
  425.     return packets;
  426. }

  428. static TSMStreamLace *
  429. createStreamLace(unsigned int numStreams)
  430. {
  431.     unsigned int i;
  432.     TSMStreamLace * lace = (TSMStreamLace *)malloc(sizeof(TSMStreamLace));
  433.     lace->streams = (TSMPacketList **)malloc(sizeof(TSMPacketList *) * numStreams);
  434.     
  435.     for ( i = 0; i < numStreams; i++)
  436.     {
  437.         lace->streams[i] = createPacketList();
  438.     }

  440.     lace->numStreams = numStreams;
  441.     return lace;
  442. }

  444. static void
  445. insertPacket(TSMStreamLace * lace, const AVPacket * packet, double timeStamp)
  446. {
  447.     fifoPush(lace->streams[packet->stream_index], packet, timeStamp);
  448. }

  450. static TSMPacketList *
  451. chooseNextStream(TSMStreamLace * lace)
  452. {
  453.     /* improve lacing so that that audio/video packets that should be
  454.        together do not get stuck into separate segments. */
  455.     
  456.     TSMPacketList * nextStream = NULL;
  457.     double earliestTimeStamp = DBL_MAX;
  458.     unsigned int i;
  459.     for (i = 0; i < lace->numStreams; i++)
  460.     {
  461.         TSMPacketList * stream = lace->streams[i];
  462.         if (stream->size && stream->head->timeStamp < earliestTimeStamp)
  463.         {
  464.             nextStream = stream;
  465.             earliestTimeStamp = stream->head->timeStamp;
  466.         }
  467.     }
  468.     
  469.     return nextStream;
  470. }

  472. static int
  473. removePacket(TSMStreamLace * lace, AVPacket * packet)
  474. {
  475.     TSMPacketList * stream = chooseNextStream(lace);
  476.     if (!stream)
  477.     {
  478.         return 0;
  479.     }
  480.     
  481.     return fifoPop(stream, packet);
  482. }

  484. static unsigned int
  485. countPackets(const TSMStreamLace * lace)
  486. {
  487.     unsigned int numPackets = 0;
  488.     unsigned int i;
  489.     for ( i = 0; i < lace->numStreams; i++)
  490.     {
  491.         const TSMPacketList * stream = lace->streams[i];
  492.         numPackets += stream->size;
  493.     }

  495.     return numPackets;
  496. }

  498. static void
  499. removeAllPackets(TSMStreamLace * lace)
  500. {
  501.     unsigned int i;
  502.     AVPacket packet;
  503.     for ( i = 0; i < lace->numStreams; i++)
  504.     {
  505.         TSMPacketList * stream = lace->streams[i];
  506.         while (stream->size)
  507.         {
  508.             fifoPop(stream, &packet);
  509.             av_free_packet(&packet);
  510.         }
  511.     }
  512. }

  514. static int
  515. loglevel(const char* arg)
  516. {
  517.     const struct { const char *name; int level; } log_levels[] = {
  518.         { "quiet" , AV_LOG_QUIET },
  519.         { "panic" , AV_LOG_PANIC },
  520.         { "fatal" , AV_LOG_FATAL },
  521.         { "error" , AV_LOG_ERROR },
  522.         { "warning", AV_LOG_WARNING },
  523.         { "info" , AV_LOG_INFO },
  524.         { "verbose", AV_LOG_VERBOSE },
  525.         { "debug" , AV_LOG_DEBUG },
  526.     };
  527.     int i;
  528.     
  529.     for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
  530.         if (!strcmp(log_levels[i].name, arg)) {
  531.             av_log_set_level(log_levels[i].level);
  532.             return 0;
  533.         }
  534.     }
  535.     
  536.     return 1;
  537. }

  539. //----------------------------------------------------------------
  540. // usage3
  541. //
  542. static void usage3(char ** argv, const char * message, const char * details)
  543. {
  544.     if (message)
  545.     {
  546.         fprintf(stderr, "ERROR: %s%s\n\n", message, details);
  547.     }
  548.     
  549.     fprintf(stderr,
  550.             "USAGE: %s "
  551.             "-i input-MPEG-TS-file "
  552.             "-d seconds-per-segment "
  553.             "[-o segment-file-prefix] "
  554.             "-x output-playlist-m3u8 "
  555.             "[-p http-prefix] "
  556.             "[-w max-live-segments] "
  557.             "[-P pid-file] "
  558.             "[--watch-for-kill-file] "
  559.             "[--strict-segment-duration] "
  560.             "[--avformat-option opt value] "
  561.             "[--loglevel level] "
  562.             "\n\n",
  563.             argv[0]);
  564.     
  565.     fprintf(stderr,
  566.             "Compiled by Daniel Espendiller - www.espend.de\n"
  567.             "build on %s %s with %s\n\n"
  568.             "Took some code from:\n"
  569.             " - source:http://svn.assembla.com/svn/legend/segmenter/\n"
  570.             " - iStreamdev:http://projects.vdr-developer.org/git/?p=istreamdev.git;a=tree;f=segmenter;hb=HEAD\n"
  571.             " - live_segmenter:http://github.com/carsonmcdonald/HTTP-Live-Video-Stream-Segmenter-and-Distributor\n",
  572.             __DATE__,
  573.             __TIME__,
  574.             __VERSION__);
  575.     
  576.     exit(1);
  577. }

  579. //----------------------------------------------------------------
  580. // usage
  581. //
  582. static void usage(char ** argv, const char * message)
  583. { usage3(argv, message, ""); }

  585. //----------------------------------------------------------------
  586. // main_utf8
  587. //
  588. int main_utf8(int argc, char **argv)
  589. {
  590.     double target_segment_duration = 0.0;
  591.     char *segment_duration_check = NULL;
  592.     const char *playlist_filename = NULL;
  593.     const char *http_prefix = "";
  594.     long max_tsfiles = 0;
  595.     char *max_tsfiles_check = NULL;
  596.     double prev_segment_time = 0.0;
  597.     double segment_duration = 0.0;
  598.     unsigned int output_index = 0;
  599.     const AVClass *fc = avformat_get_class();
  600.     AVDictionary *format_opts = NULL;
  601.     AVOutputFormat *ofmt = NULL;
  602.     AVFormatContext *ic = NULL;
  603.     AVFormatContext *oc = NULL;
  604.     AVStream *video_st = NULL;
  605.     AVStream *audio_st = NULL;
  606.     AVCodec *codec = NULL;
  607.     char *pid_filename = NULL;
  608.     int video_index = -1;
  609.     int audio_index = -1;
  610.     int kill_file = 0;
  611.     int decode_done = 0;
  612.     int ret = 0;
  613.     int i = 0;
  614.     TSMStreamLace * streamLace = NULL;
  615.     TSMPlaylist * playlist = NULL;
  616.     const double segment_duration_error_tolerance = 0.05;
  617.     double extra_duration_needed = 0;
  618.     int strict_segment_duration = 0;
  619.     
  620.     av_log_set_level(AV_LOG_INFO);
  621.     
  622.     for (i = 1; i < argc; i++)
  623.     {
  624.         if (strcmp(argv[i], "-i") == 0)
  625.         {
  626.             if ((argc - i) <= 1)
  627.                 usage(argv, "could not parse -i parameter");
  628.             i++;
  629.             strcpy(input_args.input, argv[i]);
  630.         }
  631.         else if (strcmp(argv[i], "-o") == 0)
  632.         {
  633.             if ((argc - i) <= 1)
  634.                 usage(argv, "could not parse -i parameter");
  635.             i++;
  636.             strcpy(input_args.output_prefix, argv[i]);
  637.         }
  638.         else if (strcmp(argv[i], "-d") == 0)
  639.         {
  640.             if ((argc - i) <= 1) usage(argv, "could not parse -d parameter");
  641.                 i++;
  642.             
  643.             target_segment_duration = strtod(argv[i], &segment_duration_check);
  644.             if (segment_duration_check == argv[i] ||
  645.             target_segment_duration == HUGE_VAL ||
  646.             target_segment_duration == -HUGE_VAL)
  647.             {
  648.                 usage3(argv, "invalid segment duration: ", argv[i]);
  649.             }
  650.         }
  651.         else if (strcmp(argv[i], "-x") == 0)
  652.         {
  653.             if ((argc - i) <= 1) usage(argv, "could not parse -x parameter");
  654.             i++;
  655.             playlist_filename = argv[i];
  656.         }
  657.         else if (strcmp(argv[i], "-p") == 0)
  658.         {
  659.             if ((argc - i) <= 1) usage(argv, "could not parse -p parameter");
  660.                 i++;
  661.             http_prefix = argv[i];
  662.         }
  663.         else if (strcmp(argv[i], "-w") == 0)
  664.         {
  665.             if ((argc - i) <= 1) usage(argv, "could not parse -w parameter");
  666.                 i++;

  668.             max_tsfiles = strtol(argv[i], &max_tsfiles_check, 10);
  669.             if (max_tsfiles_check == argv[i] ||
  670.                 max_tsfiles < 0 ||
  671.                 max_tsfiles >= INT_MAX)
  672.             {
  673.                 usage3(argv, "invalid live stream max window size: ", argv[i]);
  674.             }
  675.         }
  676.     }
  677.     
  678.     if (!input_args.input)
  679.     {
  680.         usage(argv, "-i input file parameter must be specified");
  681.     }
  682.     printf("+++input_file: %s\n", input_args.input);
  683.     
  684.     if (!playlist_filename)
  685.     {
  686.         usage(argv, "-x m3u8 playlist file parameter must be specified");
  687.     }
  688.     printf("+++playlist_filename: %s\n", playlist_filename);
  689.     
  690.     if (target_segment_duration == 0.0)
  691.     {
  692.         usage(argv, "-d segment duration parameter must be specified");
  693.     }
  694.     printf("+++target_segment_duration: %f\n", target_segment_duration);

  696.     av_register_all();
  697.     avformat_network_init();

  699.     if (!strcmp(input_args.input, "-")) {
  700.         strcpy(input_args.input, "pipe:");
  701.     }

  703.     playlist = createPlaylist(max_tsfiles,
  704.                               target_segment_duration,
  705.                               http_prefix);

  707.     if (!playlist)
  708.     {
  709.         fprintf(stderr, "Could not allocate space for m3u8 playlist structure\n");
  710.         goto error;
  711.     }
  712.     
  713.     ic = avformat_alloc_context();
  714.     ret = avformat_open_input(&ic, input_args.input, NULL, NULL);
  715.     if (ret != 0) {
  716.         fprintf(stderr, "Could not open input file, make sure it is an mpegts or mp4 file: %d\n", ret);
  717.         goto error;
  718.     }
  719.     
  720.     if (avformat_find_stream_info(ic, NULL) < 0) {
  721.         fprintf(stderr, "Could not read stream information\n");
  722.         goto error;
  723.     }
  724.     av_dump_format(ic, 0, input_args.input, 0);

  726.     ofmt = av_guess_format("mpegts", NULL, NULL);
  727.     if (!ofmt) {
  728.         fprintf(stderr, "Could not find MPEG-TS muxer\n");
  729.         goto error;
  730.     }

  732.     oc = avformat_alloc_context();
  733.     if (!oc) {
  734.         fprintf(stderr, "Could not allocated output context\n");
  735.         goto error;
  736.     }
  737.     oc->oformat = ofmt;
  738.     
  739.     video_index = -1;
  740.     audio_index = -1;
  741.     for (i = 0; i < ic->nb_streams && (video_index < 0 || audio_index < 0); i++) {
  742.         switch (ic->streams[i]->codec->codec_type) {
  743.         case AVMEDIA_TYPE_VIDEO:
  744.             video_index = i;
  745.             ic->streams[i]->discard = AVDISCARD_NONE;
  746.             video_st = add_output_stream(oc, ic->streams[i]);
  747.         break;
  748.         case AVMEDIA_TYPE_AUDIO:
  749.             audio_index = i;
  750.             ic->streams[i]->discard = AVDISCARD_NONE;
  751.             audio_st = add_output_stream(oc, ic->streams[i]);
  752.         break;
  753.         default:
  754.             ic->streams[i]->discard = AVDISCARD_ALL;
  755.         break;
  756.         }
  757.     }

  759.     av_dump_format(oc, 0, input_args.output_prefix, 1);
  760.     if (video_index >=0) {
  761.         codec = avcodec_find_decoder(video_st->codec->codec_id);
  762.         if (!codec) {
  763.             fprintf(stderr, "Could not find video decoder, key frames will not be honored\n");
  764.         }

  766.         if (avcodec_open2(video_st->codec, codec, NULL) < 0) {
  767.             fprintf(stderr, "Could not open video decoder, key frames will not be honored\n");
  768.         }
  769.     }
  770.     sprintf(input_args.output, "%s-%u.ts", input_args.output_prefix, ++output_index);
  771.     if (avio_open(&oc->pb, input_args.output, AVIO_FLAG_WRITE) < 0) {
  772.         fprintf(stderr, "Could not open '%s'\n", input_args.output);
  773.         goto error;
  774.     }

  776.     if (avformat_write_header(oc, NULL)) {
  777.         fprintf(stderr, "Could not write mpegts header to first output file\n");
  778.         goto error;
  779.     }

  781.     prev_segment_time = (double)(ic->start_time) / (double)(AV_TIME_BASE);

  783.     streamLace = createStreamLace(ic->nb_streams);
  784.     
  785.     do {
  786.         double segment_time = 0.0;
  787.         AVPacket packet;
  788.         double packetStartTime = 0.0;
  789.         double packetDuration = 0.0;
  790.         
  791.         if (!decode_done)
  792.         {
  793.             decode_done = av_read_frame(ic, &packet);
  794.             if (!decode_done)
  795.             {
  796.                 if (packet.stream_index != video_index &&
  797.                     packet.stream_index != audio_index)
  798.                 {
  799.                     av_free_packet(&packet);
  800.                     continue;
  801.                 }
  802.                 
  803.                 double timeStamp =
  804.                     (double)(packet.pts) *
  805.                     (double)(ic->streams[packet.stream_index]->time_base.num) /
  806.                     (double)(ic->streams[packet.stream_index]->time_base.den);
  807.                 
  808.                 if (av_dup_packet(&packet) < 0)
  809.                 {
  810.                     fprintf(stderr, "Could not duplicate packet\n");
  811.                     av_free_packet(&packet);
  812.                     break;
  813.                 }
  814.                 
  815.                 insertPacket(streamLace, &packet, timeStamp);
  816.             }
  817.         }
  818.         
  819.         if (countPackets(streamLace) < 50 && !decode_done)
  820.         {
  821.             /* allow the queue to fill up so that the packets can be sorted properly */
  822.             continue;
  823.         }
  824.         
  825.         if (!removePacket(streamLace, &packet))
  826.         {
  827.             if (decode_done)
  828.             {
  829.                 /* the queue is empty, we are done */
  830.                 break;
  831.             }
  832.             
  833.             assert(decode_done);
  834.             continue;
  835.         }
  836.         
  837.         packetStartTime =
  838.             (double)(packet.pts) *
  839.             (double)(ic->streams[packet.stream_index]->time_base.num) /
  840.             (double)(ic->streams[packet.stream_index]->time_base.den);
  841.         
  842.         packetDuration =
  843.             (double)(packet.duration) *
  844.             (double)(ic->streams[packet.stream_index]->time_base.num) /
  845.             (double)(ic->streams[packet.stream_index]->time_base.den);
  846.         
  847. #if !defined(NDEBUG) && (defined(DEBUG) || defined(_DEBUG))
  848.         if (av_log_get_level() >= AV_LOG_VERBOSE)
  849.             fprintf(stderr,
  850.                     "stream %i, packet [%f, %f)\n",
  851.                     packet.stream_index,
  852.                     packetStartTime,
  853.                     packetStartTime + packetDuration);
  854. #endif

  856.         segment_duration = packetStartTime + packetDuration - prev_segment_time;

  858.         // NOTE: segments are supposed to start on a keyframe.
  859.         // If the keyframe interval and segment duration do not match
  860.         // forcing the segment creation for "better seeking behavior"
  861.         // will result in decoding artifacts after seeking or stream switching.
  862.         if (packet.stream_index == video_index && (packet.flags & AV_PKT_FLAG_KEY || strict_segment_duration)) {
  863.             segment_time = packetStartTime;
  864.         }
  865.         else if (video_index < 0) {
  866.             segment_time = packetStartTime;
  867.         }
  868.         else {
  869.             segment_time = prev_segment_time;
  870.         }

  872.     printf("segment time: %f\n", segment_time);
  873.         if (segment_time - prev_segment_time + segment_duration_error_tolerance >
  874.             target_segment_duration + extra_duration_needed)
  875.         {
  876.             avio_flush(oc->pb);
  877.             avio_close(oc->pb);

  879.             // Keep track of accumulated rounding error to account for it in later chunks.
  880.             double segment_duration = segment_time - prev_segment_time;
  881.             int rounded_segment_duration = (int)(segment_duration + 0.5);
  882.             extra_duration_needed += (double)rounded_segment_duration - segment_duration;

  884.             updatePlaylist(playlist,
  885.                            playlist_filename,
  886.                            input_args.output,
  887.                            output_index,
  888.                            rounded_segment_duration);
  889.             
  890.             sprintf(input_args.output, "%s-%u.ts", input_args.output_prefix, ++output_index);
  891.             if (avio_open(&oc->pb, input_args.output, AVIO_FLAG_WRITE) < 0) {
  892.                 fprintf(stderr, "Could not open '%s'\n", input_args.output);
  893.                 break;
  894.             }

  896.             // close when we find the 'kill' file
  897.             if (kill_file) {
  898.                 FILE* fp = fopen("kill", "rb");
  899.                 if (fp) {
  900.                     fprintf(stderr, "user abort: found kill file\n");
  901.                     fclose(fp);
  902.                     remove("kill");
  903.                     decode_done = 1;
  904.                     removeAllPackets(streamLace);
  905.                 }
  906.             }
  907.             prev_segment_time = segment_time;
  908.         }

  910.         ret = av_interleaved_write_frame(oc, &packet);
  911.         if (ret < 0) {
  912.             fprintf(stderr, "Warning: Could not write frame of stream\n");
  913.         }
  914.         else if (ret > 0) {
  915.             fprintf(stderr, "End of stream requested\n");
  916.             av_free_packet(&packet);
  917.             break;
  918.         }

  920.         av_free_packet(&packet);
  921.     } while (!decode_done || countPackets(streamLace) > 0);

  923.     av_write_trailer(oc);

  925.     if (video_index >= 0) {
  926.       avcodec_close(video_st->codec);
  927.     }

  929.     for(i = 0; i < oc->nb_streams; i++) {
  930.         av_freep(&oc->streams[i]->codec);
  931.         av_freep(&oc->streams[i]);
  932.     }

  934.     avio_close(oc->pb);
  935.     av_free(oc);

  937.     updatePlaylist(playlist,
  938.                    playlist_filename,
  939.                    input_args.output,
  940.                    output_index,
  941.                    segment_duration);
  942.     closePlaylist(playlist);
  943.     releasePlaylist(&playlist);
  944.     
  945.     if (pid_filename)
  946.     {
  947.         remove(pid_filename);
  948.     }
  949.     return 0;

  951. error:
  952.     if (pid_filename)
  953.     {
  954.         remove(pid_filename);
  955.     }

  957.     return 1;

  959. }

  961. int main(int argc, char ** argv)
  962. {
  963.     return main_utf8(argc, argv);
  964. }


四、准备webserver， 建议用lighttpd。
下载最新的lighttpd-1.4.32，
./configure –prefix=dir
Make && make install
下面就是配置了：


server.modules必须启用：
mod_access
在mimetype.assign当中加入：
".m3u8"         =>      "application/x-mpegURL", 
  ".ts"           =>      "video/MP2T",
server.document-root 设置为你的目录，记住设置下面：
index-file.names            = ( "index.php", "index.html",
                                "index.htm", "default.htm",
                                "index.lighttpd.html")
打开http://IP:port时发现出现404 not foud，这说明你的server已经成功启动，你要做的就是把/var/www/ index.lighttpd.html 拷贝到你的目录下，你就可以打开这个html了。
五、设置好网络以后，将index.m3u8和相关文件按照自定义顺序拷贝到server的目录下，然后就可以开始试验了。
六、打开IOS，在movie player当中输入http://iP/index.m3u8，播放即可，非常流畅。


10-11 20:30
Powered by LMLPHP ©2024 fduop07 0.073550