From e96b9500dbec61236317567db4834dc095db1c2b Mon Sep 17 00:00:00 2001 From: ejurgensen Date: Sun, 26 Feb 2017 23:41:30 +0100 Subject: [PATCH] [transcode] Implement new ffmpeg decoding methods: avcodec_send_packet/avcodec_receive_frame --- src/httpd.c | 4 +- src/httpd_streaming.c | 6 +- src/input.c | 2 +- src/inputs/file_http.c | 4 +- src/transcode.c | 452 ++++++++++++++++++++--------------------- src/transcode.h | 39 ++-- 6 files changed, 249 insertions(+), 258 deletions(-) diff --git a/src/httpd.c b/src/httpd.c index 5b01681a..79ab8b86 100644 --- a/src/httpd.c +++ b/src/httpd.c @@ -167,7 +167,7 @@ stream_end(struct stream_ctx *st, int failed) event_free(st->ev); if (st->xcode) - transcode_cleanup(st->xcode); + transcode_cleanup(&st->xcode); else { free(st->buf); @@ -750,7 +750,7 @@ httpd_stream_file(struct evhttp_request *req, int id) if (st->evbuf) evbuffer_free(st->evbuf); if (st->xcode) - transcode_cleanup(st->xcode); + transcode_cleanup(&st->xcode); if (st->buf) free(st->buf); if (st->fd > 0) diff --git a/src/httpd_streaming.c b/src/httpd_streaming.c index 115f4021..f5262b9c 100644 --- a/src/httpd_streaming.c +++ b/src/httpd_streaming.c @@ -300,7 +300,7 @@ streaming_init(void) } streaming_encode_ctx = transcode_encode_setup(XCODE_MP3, decode_ctx, NULL); - transcode_decode_cleanup(decode_ctx); + transcode_decode_cleanup(&decode_ctx); if (!streaming_encode_ctx) { DPRINTF(E_LOG, L_STREAMING, "Will not be able to stream mp3, libav does not support mp3 encoding\n"); @@ -399,7 +399,7 @@ streaming_init(void) close(streaming_pipe[0]); close(streaming_pipe[1]); pipe_fail: - transcode_encode_cleanup(streaming_encode_ctx); + transcode_encode_cleanup(&streaming_encode_ctx); return -1; } @@ -432,7 +432,7 @@ streaming_deinit(void) close(streaming_pipe[0]); close(streaming_pipe[1]); - transcode_encode_cleanup(streaming_encode_ctx); + transcode_encode_cleanup(&streaming_encode_ctx); evbuffer_free(streaming_encoded_data); free(streaming_silence_data); } diff --git a/src/input.c b/src/input.c index 863b4706..8c8dd3d5 100644 --- a/src/input.c +++ b/src/input.c @@ -483,7 +483,7 @@ input_flush(short *flags) pthread_mutex_unlock(&input_buffer.mutex); #ifdef DEBUG - DPRINTF(E_DBG, L_PLAYER, "Flush with flags %d\n", *flags); + DPRINTF(E_DBG, L_PLAYER, "Flushing %zu bytes with flags %d\n", len, *flags); #endif } diff --git a/src/inputs/file_http.c b/src/inputs/file_http.c index 6335a5b3..de0517c4 100644 --- a/src/inputs/file_http.c +++ b/src/inputs/file_http.c @@ -90,7 +90,9 @@ start(struct player_source *ps) static int stop(struct player_source *ps) { - transcode_cleanup(ps->input_ctx); + struct transcode_ctx *ctx = ps->input_ctx; + + transcode_cleanup(&ctx); ps->input_ctx = NULL; ps->setup_done = 0; diff --git a/src/transcode.c b/src/transcode.c index a587081a..e529df64 100644 --- a/src/transcode.c +++ b/src/transcode.c @@ -117,12 +117,14 @@ struct decode_ctx // Data kind (used to determine if ICY metadata is relevant to look for) enum data_kind data_kind; - // Contains the most recent packet from av_read_frame - // Used for resuming after seek and for freeing correctly - // in transcode_decode() - AVPacket packet; - int resume; - int resume_offset; + // Set to true if we just seeked + bool resume; + + // Contains the most recent packet from av_read_frame() + AVPacket *packet; + + // Contains the most recent frame from avcodec_receive_frame() + AVFrame *decoded_frame; // Used to measure if av_read_frame is taking too long int64_t timestamp; @@ -164,6 +166,8 @@ struct transcode_ctx { struct decode_ctx *decode_ctx; struct encode_ctx *encode_ctx; + + bool eof; }; struct decoded_frame @@ -407,56 +411,42 @@ static int decode_interrupt_cb(void *arg) return 0; } -/* Will read the next packet from the source, unless we are in resume mode, in - * which case the most recent packet will be returned, but with an adjusted data - * pointer. Use ctx->resume and ctx->resume_offset to make the function resume - * from the most recent packet. +/* Will read the next packet from the source, unless we are resuming after a + * seek in which case the most recent packet found by transcode_seek() will be + * returned. The packet will be put in ctx->packet. * - * @out packet Pointer to an already allocated AVPacket. The content of the - * packet will be updated, and packet->data is pointed to the data - * returned by av_read_frame(). The packet struct is owned by the - * caller, but *not* packet->data, so don't free the packet with - * av_free_packet()/av_packet_unref() * @out type Media type of packet * @in ctx Decode context * @return 0 if OK, < 0 on error or end of file */ static int -read_packet(AVPacket *packet, enum AVMediaType *type, struct decode_ctx *ctx) +read_packet(enum AVMediaType *type, struct decode_ctx *dec_ctx) { int ret; + // We just seeked, so transcode_seek() will have found a new ctx->packet and + // we should just use start with that (if the stream is one are ok with) + if (dec_ctx->resume) + { + dec_ctx->resume = 0; + *type = stream_find(dec_ctx, dec_ctx->packet->stream_index); + if (*type != AVMEDIA_TYPE_UNKNOWN) + return 0; + } + do { - if (ctx->resume) + dec_ctx->timestamp = av_gettime(); + + av_packet_unref(dec_ctx->packet); + ret = av_read_frame(dec_ctx->ifmt_ctx, dec_ctx->packet); + if (ret < 0) { - // Copies packet struct, but not actual packet payload, and adjusts - // data pointer to somewhere inside the payload if resume_offset is set - *packet = ctx->packet; - packet->data += ctx->resume_offset; - packet->size -= ctx->resume_offset; - ctx->resume = 0; - } - else - { - // We are going to read a new packet from source, so now it is safe to - // discard the previous packet and reset resume_offset - av_packet_unref(&ctx->packet); - - ctx->resume_offset = 0; - ctx->timestamp = av_gettime(); - - ret = av_read_frame(ctx->ifmt_ctx, &ctx->packet); - if (ret < 0) - { - DPRINTF(E_WARN, L_XCODE, "Could not read frame: %s\n", err2str(ret)); - return ret; - } - - *packet = ctx->packet; + DPRINTF(E_WARN, L_XCODE, "Could not read frame: %s\n", err2str(ret)); + return ret; } - *type = stream_find(ctx, packet->stream_index); + *type = stream_find(dec_ctx, dec_ctx->packet->stream_index); } while (*type == AVMEDIA_TYPE_UNKNOWN); @@ -484,6 +474,10 @@ packet_prepare(AVPacket *pkt, struct stream_ctx *s) av_packet_rescale_ts(pkt, s->codec->time_base, s->stream->time_base); } +/* + * Part 4 of the conversion chain: read -> decode -> filter -> encode -> write + * + */ static int encode_write(struct encode_ctx *ctx, struct stream_ctx *s, AVFrame *filt_frame) { @@ -515,6 +509,12 @@ encode_write(struct encode_ctx *ctx, struct stream_ctx *s, AVFrame *filt_frame) return ret; } +/* + * Part 3 of the conversion chain: read -> decode -> filter -> encode -> write + * + * transcode_encode() starts here since the caller already has a frame + * + */ static int filter_encode_write(struct encode_ctx *ctx, struct stream_ctx *s, AVFrame *frame) { @@ -554,34 +554,92 @@ filter_encode_write(struct encode_ctx *ctx, struct stream_ctx *s, AVFrame *frame return ret; } -/* Will step through each stream and feed the stream decoder with empty packets - * to see if the decoder has more frames lined up. Will return non-zero if a - * frame is found. Should be called until it stops returning anything. +/* + * Part 2 of the conversion chain: read -> decode -> filter -> encode -> write + * + * If there is no encode_ctx the chain will aborted here * - * @out frame AVFrame if there was anything to flush, otherwise undefined - * @out stream Set to the AVStream where a decoder returned a frame - * @in ctx Decode context - * @return Non-zero (true) if frame found, otherwise 0 (false) */ static int -flush_decoder(AVFrame *frame, enum AVMediaType *type, struct decode_ctx *ctx) +decode_filter_encode_write(struct transcode_ctx *ctx, struct stream_ctx *s, AVPacket *pkt, enum AVMediaType type) { - AVPacket dummypacket = { 0 }; - int got_frame = 0; + struct decode_ctx *dec_ctx = ctx->decode_ctx; + struct stream_ctx *out_stream = NULL; + int ret; - if (ctx->audio_stream.codec) + ret = avcodec_send_packet(s->codec, pkt); + if (ret < 0) + return ret; + + if (ctx->encode_ctx) { - *type = AVMEDIA_TYPE_AUDIO; - avcodec_decode_audio4(ctx->audio_stream.codec, frame, &got_frame, &dummypacket); + if (type == AVMEDIA_TYPE_AUDIO) + out_stream = &ctx->encode_ctx->audio_stream; + else if (type == AVMEDIA_TYPE_VIDEO) + out_stream = &ctx->encode_ctx->video_stream; + else + return -1; } - if (!got_frame && ctx->video_stream.codec) + while (1) { - *type = AVMEDIA_TYPE_VIDEO; - avcodec_decode_video2(ctx->video_stream.codec, frame, &got_frame, &dummypacket); + ret = avcodec_receive_frame(s->codec, dec_ctx->decoded_frame); + if (ret < 0) + { + if (ret == AVERROR(EAGAIN)) + ret = 0; + else if (out_stream) + ret = filter_encode_write(ctx->encode_ctx, out_stream, NULL); // Flush + + break; + } + + if (!out_stream) + break; + + ret = filter_encode_write(ctx->encode_ctx, out_stream, dec_ctx->decoded_frame); + if (ret < 0) + break; } - return got_frame; + return ret; +} + +/* + * Part 1 of the conversion chain: read -> decode -> filter -> encode -> write + * + * Will read exactly one packet from the input and put it in the chain. You + * cannot count on anything coming out of the other end from just one packet, + * so you probably should loop when calling this and check the contents of + * enc_ctx->obuf. + * + */ +static int +read_decode_filter_encode_write(struct transcode_ctx *ctx) +{ + struct decode_ctx *dec_ctx = ctx->decode_ctx; + enum AVMediaType type; + int ret; + + ret = read_packet(&type, dec_ctx); + if (ret < 0) + { + DPRINTF(E_DBG, L_XCODE, "No more input, flushing codecs\n"); + + if (dec_ctx->audio_stream.stream) + decode_filter_encode_write(ctx, &dec_ctx->audio_stream, NULL, AVMEDIA_TYPE_AUDIO); + if (dec_ctx->video_stream.stream) + decode_filter_encode_write(ctx, &dec_ctx->video_stream, NULL, AVMEDIA_TYPE_VIDEO); + + return ret; + } + + if (type == AVMEDIA_TYPE_AUDIO) + ret = decode_filter_encode_write(ctx, &dec_ctx->audio_stream, dec_ctx->packet, type); + else if (type == AVMEDIA_TYPE_VIDEO) + ret = decode_filter_encode_write(ctx, &dec_ctx->video_stream, dec_ctx->packet, type); + + return ret; } @@ -762,6 +820,11 @@ open_output(struct encode_ctx *ctx, struct decode_ctx *src_ctx) goto out_free_streams; } + if (ctx->settings.wavheader) + { + evbuffer_add(ctx->obuf, ctx->header, sizeof(ctx->header)); + } + return 0; out_free_streams: @@ -987,19 +1050,22 @@ transcode_decode_setup(enum transcode_profile profile, enum data_kind data_kind, struct decode_ctx *ctx; CHECK_NULL(L_XCODE, ctx = calloc(1, sizeof(struct decode_ctx))); - - av_init_packet(&ctx->packet); + CHECK_NULL(L_XCODE, ctx->decoded_frame = av_frame_alloc()); + CHECK_NULL(L_XCODE, ctx->packet = av_packet_alloc()); ctx->duration = song_length; ctx->data_kind = data_kind; if ((init_settings(&ctx->settings, profile) < 0) || (open_input(ctx, path) < 0)) - { - free(ctx); - return NULL; - } + goto fail_free; return ctx; + + fail_free: + av_packet_free(&ctx->packet); + av_frame_free(&ctx->decoded_frame); + free(ctx); + return NULL; } struct encode_ctx * @@ -1011,26 +1077,30 @@ transcode_encode_setup(enum transcode_profile profile, struct decode_ctx *src_ct CHECK_NULL(L_XCODE, ctx->filt_frame = av_frame_alloc()); CHECK_NULL(L_XCODE, ctx->encoded_pkt = av_packet_alloc()); - if ((init_settings(&ctx->settings, profile) < 0) || (open_output(ctx, src_ctx) < 0)) - { - free(ctx); - return NULL; - } - - if (open_filters(ctx, src_ctx) < 0) - { - close_output(ctx); - free(ctx); - return NULL; - } - - if (src_ctx->data_kind == DATA_KIND_HTTP) - ctx->icy_interval = METADATA_ICY_INTERVAL * ctx->settings.channels * ctx->settings.byte_depth * ctx->settings.sample_rate; + if (init_settings(&ctx->settings, profile) < 0) + goto fail_free; if (ctx->settings.wavheader) make_wav_header(ctx, src_ctx, est_size); + if (open_output(ctx, src_ctx) < 0) + goto fail_free; + + if (open_filters(ctx, src_ctx) < 0) + goto fail_close; + + if (src_ctx->data_kind == DATA_KIND_HTTP) + ctx->icy_interval = METADATA_ICY_INTERVAL * ctx->settings.channels * ctx->settings.byte_depth * ctx->settings.sample_rate; + return ctx; + + fail_close: + close_output(ctx); + fail_free: + av_packet_free(&ctx->encoded_pkt); + av_frame_free(&ctx->filt_frame); + free(ctx); + return NULL; } struct transcode_ctx * @@ -1038,7 +1108,7 @@ transcode_setup(enum transcode_profile profile, enum data_kind data_kind, const { struct transcode_ctx *ctx; - CHECK_NULL(L_XCODE, ctx = malloc(sizeof(struct transcode_ctx))); + CHECK_NULL(L_XCODE, ctx = calloc(1, sizeof(struct transcode_ctx))); ctx->decode_ctx = transcode_decode_setup(profile, data_kind, path, song_length); if (!ctx->decode_ctx) @@ -1050,7 +1120,7 @@ transcode_setup(enum transcode_profile profile, enum data_kind data_kind, const ctx->encode_ctx = transcode_encode_setup(profile, ctx->decode_ctx, est_size); if (!ctx->encode_ctx) { - transcode_decode_cleanup(ctx->decode_ctx); + transcode_decode_cleanup(&ctx->decode_ctx); free(ctx); return NULL; } @@ -1192,43 +1262,54 @@ transcode_needed(const char *user_agent, const char *client_codecs, char *file_c /* Cleanup */ void -transcode_decode_cleanup(struct decode_ctx *ctx) +transcode_decode_cleanup(struct decode_ctx **ctx) { - av_packet_unref(&ctx->packet); - close_input(ctx); - free(ctx); + if (!(*ctx)) + return; + + close_input(*ctx); + + av_packet_free(&(*ctx)->packet); + av_frame_free(&(*ctx)->decoded_frame); + free(*ctx); + *ctx = NULL; } void -transcode_encode_cleanup(struct encode_ctx *ctx) +transcode_encode_cleanup(struct encode_ctx **ctx) { + if (!*ctx) + return; + // Flush audio encoder - if (ctx->audio_stream.stream) - filter_encode_write(ctx, &ctx->audio_stream, NULL); + if ((*ctx)->audio_stream.stream) + filter_encode_write(*ctx, &(*ctx)->audio_stream, NULL); // Flush video encoder - if (ctx->video_stream.stream) - filter_encode_write(ctx, &ctx->video_stream, NULL); + if ((*ctx)->video_stream.stream) + filter_encode_write(*ctx, &(*ctx)->video_stream, NULL); // Flush muxer - av_interleaved_write_frame(ctx->ofmt_ctx, NULL); + av_interleaved_write_frame((*ctx)->ofmt_ctx, NULL); - av_write_trailer(ctx->ofmt_ctx); + av_write_trailer((*ctx)->ofmt_ctx); - close_filters(ctx); - close_output(ctx); + close_filters(*ctx); + close_output(*ctx); - av_packet_free(&ctx->encoded_pkt); - av_frame_free(&ctx->filt_frame); - free(ctx); + av_packet_free(&(*ctx)->encoded_pkt); + av_frame_free(&(*ctx)->filt_frame); + free(*ctx); + *ctx = NULL; } void -transcode_cleanup(struct transcode_ctx *ctx) +transcode_cleanup(struct transcode_ctx **ctx) { - transcode_encode_cleanup(ctx->encode_ctx); - transcode_decode_cleanup(ctx->decode_ctx); - free(ctx); + transcode_encode_cleanup(&(*ctx)->encode_ctx); + transcode_decode_cleanup(&(*ctx)->decode_ctx); + free(*ctx); + *ctx = NULL; } void @@ -1241,103 +1322,11 @@ transcode_decoded_free(struct decoded_frame *decoded) /* Encoding, decoding and transcoding */ - int -transcode_decode(struct decoded_frame **decoded, struct decode_ctx *ctx) +transcode_decode(struct decoded_frame **decoded, struct decode_ctx *dec_ctx) { - AVPacket packet; - AVFrame *frame; - enum AVMediaType type; - int got_frame; - int retry; - int ret; - int used; - - // Alloc the frame we will return on success - frame = av_frame_alloc(); - if (!frame) - { - DPRINTF(E_LOG, L_XCODE, "Out of memory for decode frame\n"); - - return -1; - } - - // Loop until we either fail or get a frame - retry = 0; - do - { - ret = read_packet(&packet, &type, ctx); - if (ret < 0) - { - // Some decoders need to be flushed, meaning the decoder is to be called - // with empty input until no more frames are returned - DPRINTF(E_DBG, L_XCODE, "Could not read packet, will flush decoders\n"); - - got_frame = flush_decoder(frame, &type, ctx); - if (got_frame) - break; - - av_frame_free(&frame); - if (ret == AVERROR_EOF) - return 0; - else - return -1; - } - - // "used" will tell us how much of the packet was decoded. We may - // not get a frame because of insufficient input, in which case we loop to - // read another packet. - if (type == AVMEDIA_TYPE_AUDIO) - used = avcodec_decode_audio4(ctx->audio_stream.codec, frame, &got_frame, &packet); - else - used = avcodec_decode_video2(ctx->video_stream.codec, frame, &got_frame, &packet); - - // decoder returned an error, but maybe the packet was just a bad apple, - // so let's try MAX_BAD_PACKETS times before giving up - if (used < 0) - { - DPRINTF(E_DBG, L_XCODE, "Couldn't decode packet: %s\n", err2str(used)); - - retry += 1; - if (retry < MAX_BAD_PACKETS) - continue; - - DPRINTF(E_LOG, L_XCODE, "Couldn't decode packet after %i retries: %s\n", MAX_BAD_PACKETS, err2str(used)); - - av_frame_free(&frame); - return -1; - } - - // decoder didn't process the entire packet, so flag a resume, meaning - // that the next read_packet() will return this same packet, but where the - // data pointer is adjusted with an offset - if (used < packet.size) - { - DPRINTF(E_SPAM, L_XCODE, "Decoder did not finish packet, packet will be resumed\n"); - - ctx->resume_offset += used; - ctx->resume = 1; - } - } - while (!got_frame); - - if (got_frame > 0) - { - // Return the decoded frame and stream index - *decoded = malloc(sizeof(struct decoded_frame)); - if (!(*decoded)) - { - DPRINTF(E_LOG, L_XCODE, "Out of memory for decoded result\n"); - - av_frame_free(&frame); - return -1; - } - - (*decoded)->frame = frame; - (*decoded)->type = type; - } - - return got_frame; + DPRINTF(E_LOG, L_XCODE, "Bug! Call to transcode_decode(), but the lazy programmer didn't implement it\n"); + return -1; } // Filters and encodes @@ -1345,10 +1334,10 @@ int transcode_encode(struct evbuffer *evbuf, struct decoded_frame *decoded, struct encode_ctx *ctx) { struct stream_ctx *s; - int encoded_length; + size_t start_length; int ret; - encoded_length = 0; + start_length = evbuffer_get_length(ctx->obuf); if (decoded->type == AVMEDIA_TYPE_AUDIO) s = &ctx->audio_stream; @@ -1357,54 +1346,55 @@ transcode_encode(struct evbuffer *evbuf, struct decoded_frame *decoded, struct e else return -1; - if (ctx->settings.wavheader) - { - encoded_length += sizeof(ctx->header); - evbuffer_add(evbuf, ctx->header, sizeof(ctx->header)); - ctx->settings.wavheader = 0; - } - ret = filter_encode_write(ctx, s, decoded->frame); if (ret < 0) { - DPRINTF(E_LOG, L_XCODE, "Error occurred: %s\n", err2str(ret)); + DPRINTF(E_LOG, L_XCODE, "Error occurred while encoding: %s\n", err2str(ret)); return ret; } - encoded_length += evbuffer_get_length(ctx->obuf); + ret = evbuffer_get_length(ctx->obuf) - start_length; + evbuffer_add_buffer(evbuf, ctx->obuf); - return encoded_length; + return ret; } int -transcode(struct evbuffer *evbuf, int wanted, struct transcode_ctx *ctx, int *icy_timer) +transcode(struct evbuffer *evbuf, int want_bytes, struct transcode_ctx *ctx, int *icy_timer) { - struct decoded_frame *decoded; - int processed; + size_t start_length; + int processed = 0; int ret; *icy_timer = 0; - processed = 0; - while (processed < wanted) + if (ctx->eof) + return 0; + + start_length = evbuffer_get_length(ctx->encode_ctx->obuf); + + do { - ret = transcode_decode(&decoded, ctx->decode_ctx); - if (ret <= 0) - return ret; - - ret = transcode_encode(evbuf, decoded, ctx->encode_ctx); - transcode_decoded_free(decoded); - if (ret < 0) - return -1; - - processed += ret; + ret = read_decode_filter_encode_write(ctx); + processed = evbuffer_get_length(ctx->encode_ctx->obuf) - start_length; } + while ((ret == 0) && (!want_bytes || (processed < want_bytes))); + + evbuffer_add_buffer(evbuf, ctx->encode_ctx->obuf); ctx->encode_ctx->total_bytes += processed; if (ctx->encode_ctx->icy_interval) *icy_timer = (ctx->encode_ctx->total_bytes % ctx->encode_ctx->icy_interval < processed); + if (ret == AVERROR_EOF) + { + ctx->eof = 1; + ret = 0; + } + else if (ret < 0) + return ret; + return processed; } @@ -1496,11 +1486,10 @@ transcode_seek(struct transcode_ctx *ctx, int ms) s->codec->skip_frame = AVDISCARD_NONREF; while (1) { - av_packet_unref(&dec_ctx->packet); - dec_ctx->timestamp = av_gettime(); - ret = av_read_frame(dec_ctx->ifmt_ctx, &dec_ctx->packet); + av_packet_unref(dec_ctx->packet); + ret = av_read_frame(dec_ctx->ifmt_ctx, dec_ctx->packet); if (ret < 0) { DPRINTF(E_WARN, L_XCODE, "Could not read more data while seeking: %s\n", err2str(ret)); @@ -1508,23 +1497,22 @@ transcode_seek(struct transcode_ctx *ctx, int ms) return -1; } - if (stream_find(dec_ctx, dec_ctx->packet.stream_index) == AVMEDIA_TYPE_UNKNOWN) + if (stream_find(dec_ctx, dec_ctx->packet->stream_index) == AVMEDIA_TYPE_UNKNOWN) continue; // Need a pts to return the real position - if (dec_ctx->packet.pts == AV_NOPTS_VALUE) + if (dec_ctx->packet->pts == AV_NOPTS_VALUE) continue; break; } s->codec->skip_frame = AVDISCARD_DEFAULT; - // Tell transcode_decode() to resume with ctx->packet + // Tell read_packet() to resume with dec_ctx->packet dec_ctx->resume = 1; - dec_ctx->resume_offset = 0; // Compute position in ms from pts - got_pts = dec_ctx->packet.pts; + got_pts = dec_ctx->packet->pts; if ((start_time != AV_NOPTS_VALUE) && (start_time > 0)) got_pts -= start_time; diff --git a/src/transcode.h b/src/transcode.h index c6d60cd7..e55128bd 100644 --- a/src/transcode.h +++ b/src/transcode.h @@ -42,13 +42,13 @@ transcode_needed(const char *user_agent, const char *client_codecs, char *file_c // Cleaning up void -transcode_decode_cleanup(struct decode_ctx *ctx); +transcode_decode_cleanup(struct decode_ctx **ctx); void -transcode_encode_cleanup(struct encode_ctx *ctx); +transcode_encode_cleanup(struct encode_ctx **ctx); void -transcode_cleanup(struct transcode_ctx *ctx); +transcode_cleanup(struct transcode_ctx **ctx); void transcode_decoded_free(struct decoded_frame *decoded); @@ -57,35 +57,36 @@ transcode_decoded_free(struct decoded_frame *decoded); /* Demuxes and decodes the next packet from the input. * - * @out decoded A newly allocated struct with a pointer to the frame and the - * stream. Must be freed with transcode_decoded_free(). - * @in ctx Decode context - * @return Positive if OK, negative if error, 0 if EOF + * @out decoded A newly allocated struct with a pointer to the frame and the + * stream. Must be freed with transcode_decoded_free(). + * @in ctx Decode context + * @return Positive if OK, negative if error, 0 if EOF */ int transcode_decode(struct decoded_frame **decoded, struct decode_ctx *ctx); /* Encodes and remuxes a frame. Also resamples if needed. * - * @out evbuf An evbuffer filled with remuxed data - * @in frame The frame to encode, e.g. from transcode_decode - * @in wanted Bytes that the caller wants processed - * @in ctx Encode context - * @return Length of evbuf if OK, negative if error + * @out evbuf An evbuffer filled with remuxed data + * @in frame The frame to encode, e.g. from transcode_decode + * @in ctx Encode context + * @return Bytes added if OK, negative if error */ int transcode_encode(struct evbuffer *evbuf, struct decoded_frame *decoded, struct encode_ctx *ctx); -/* Demuxes, decodes, encodes and remuxes the next packet from the input. +/* Demuxes, decodes, encodes and remuxes from the input. * - * @out evbuf An evbuffer filled with remuxed data - * @in wanted Bytes that the caller wants processed - * @in ctx Transcode context - * @out icy_timer True if METADATA_ICY_INTERVAL has elapsed - * @return Bytes processed if OK, negative if error, 0 if EOF + * @out evbuf An evbuffer filled with remuxed data + * @in want_bytes Minimum number of bytes the caller wants added to the evbuffer + * - set want_bytes to 0 to transcode everything until EOF/error + * - set want_bytes to 1 to get one encoded packet + * @in ctx Transcode context + * @out icy_timer True if METADATA_ICY_INTERVAL has elapsed + * @return Bytes added if OK, negative if error, 0 if EOF */ int -transcode(struct evbuffer *evbuf, int wanted, struct transcode_ctx *ctx, int *icy_timer); +transcode(struct evbuffer *evbuf, int want_bytes, struct transcode_ctx *ctx, int *icy_timer); struct decoded_frame * transcode_raw2frame(uint8_t *data, size_t size);