falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
101898 Commits
32 Branches
424MB
Tree: 6e8e9b7633
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6e8e9b7633'
${ noResults }
FFmpeg/libavcodec/encode.c

683 lines
23KB
Raw Blame History 

  1. /*

  2.  * generic encoding-related code

  3.  *

  4.  * This file is part of FFmpeg.

  5.  *

  6.  * FFmpeg is free software; you can redistribute it and/or

  7.  * modify it under the terms of the GNU Lesser General Public

  8.  * License as published by the Free Software Foundation; either

  9.  * version 2.1 of the License, or (at your option) any later version.

  10.  *

  11.  * FFmpeg is distributed in the hope that it will be useful,

  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  14.  * Lesser General Public License for more details.

  15.  *

  16.  * You should have received a copy of the GNU Lesser General Public

  17.  * License along with FFmpeg; if not, write to the Free Software

  18.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  19.  */

  20. 

  21. #include "libavutil/attributes.h"

  22. #include "libavutil/avassert.h"

  23. #include "libavutil/frame.h"

  24. #include "libavutil/imgutils.h"

  25. #include "libavutil/internal.h"

  26. #include "libavutil/samplefmt.h"

  27. 

  28. #include "avcodec.h"

  29. #include "encode.h"

  30. #include "frame_thread_encoder.h"

  31. #include "internal.h"

  32. 

  33. int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)

  34. {

  35.     if (size < 0 || size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {

  36.         av_log(avctx, AV_LOG_ERROR, "Invalid minimum required packet size %"PRId64" (max allowed is %d)\n",

  37.                size, INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE);

  38.         return AVERROR(EINVAL);

  39.     }

  40. 

  41.     av_assert0(!avpkt->data);

  42. 

  43.     if (avctx && 2*min_size < size) { // FIXME The factor needs to be finetuned

  44.         av_fast_padded_malloc(&avctx->internal->byte_buffer, &avctx->internal->byte_buffer_size, size);

  45.         avpkt->data = avctx->internal->byte_buffer;

  46.         avpkt->size = size;

  47.     }

  48. 

  49.     if (!avpkt->data) {

  50.         int ret = av_new_packet(avpkt, size);

  51.         if (ret < 0)

  52.             av_log(avctx, AV_LOG_ERROR, "Failed to allocate packet of size %"PRId64"\n", size);

  53.         return ret;

  54.     }

  55. 

  56.     return 0;

  57. }

  58. 

  59. int avcodec_default_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int flags)

  60. {

  61.     int ret;

  62. 

  63.     if (avpkt->size < 0 || avpkt->size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)

  64.         return AVERROR(EINVAL);

  65. 

  66.     if (avpkt->data || avpkt->buf) {

  67.         av_log(avctx, AV_LOG_ERROR, "avpkt->{data,buf} != NULL in avcodec_default_get_encode_buffer()\n");

  68.         return AVERROR(EINVAL);

  69.     }

  70. 

  71.     ret = av_buffer_realloc(&avpkt->buf, avpkt->size + AV_INPUT_BUFFER_PADDING_SIZE);

  72.     if (ret < 0) {

  73.         av_log(avctx, AV_LOG_ERROR, "Failed to allocate packet of size %d\n", avpkt->size);

  74.         return ret;

  75.     }

  76.     avpkt->data = avpkt->buf->data;

  77.     memset(avpkt->data + avpkt->size, 0, AV_INPUT_BUFFER_PADDING_SIZE);

  78. 

  79.     return 0;

  80. }

  81. 

  82. int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)

  83. {

  84.     int ret;

  85. 

  86.     if (size < 0 || size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)

  87.         return AVERROR(EINVAL);

  88. 

  89.     av_assert0(!avpkt->data && !avpkt->buf);

  90. 

  91.     avpkt->size = size;

  92.     ret = avctx->get_encode_buffer(avctx, avpkt, flags);

  93.     if (ret < 0)

  94.         goto fail;

  95. 

  96.     if (!avpkt->data || !avpkt->buf) {

  97.         av_log(avctx, AV_LOG_ERROR, "No buffer returned by get_encode_buffer()\n");

  98.         ret = AVERROR(EINVAL);

  99.         goto fail;

  100.     }

  101. 

  102.     ret = 0;

  103. fail:

  104.     if (ret < 0) {

  105.         av_log(avctx, AV_LOG_ERROR, "get_encode_buffer() failed\n");

  106.         av_packet_unref(avpkt);

  107.     }

  108. 

  109.     return ret;

  110. }

  111. 

  112. /**

  113.  * Pad last frame with silence.

  114.  */

  115. static int pad_last_frame(AVCodecContext *s, AVFrame *frame, const AVFrame *src)

  116. {

  117.     int ret;

  118. 

  119.     frame->format         = src->format;

  120.     frame->channel_layout = src->channel_layout;

  121.     frame->channels       = src->channels;

  122.     frame->nb_samples     = s->frame_size;

  123.     ret = av_frame_get_buffer(frame, 0);

  124.     if (ret < 0)

  125.         goto fail;

  126. 

  127.     ret = av_frame_copy_props(frame, src);

  128.     if (ret < 0)

  129.         goto fail;

  130. 

  131.     if ((ret = av_samples_copy(frame->extended_data, src->extended_data, 0, 0,

  132.                                src->nb_samples, s->channels, s->sample_fmt)) < 0)

  133.         goto fail;

  134.     if ((ret = av_samples_set_silence(frame->extended_data, src->nb_samples,

  135.                                       frame->nb_samples - src->nb_samples,

  136.                                       s->channels, s->sample_fmt)) < 0)

  137.         goto fail;

  138. 

  139.     return 0;

  140. 

  141. fail:

  142.     av_frame_unref(frame);

  143.     return ret;

  144. }

  145. 

  146. int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,

  147.                             const AVSubtitle *sub)

  148. {

  149.     int ret;

  150.     if (sub->start_display_time) {

  151.         av_log(avctx, AV_LOG_ERROR, "start_display_time must be 0.\n");

  152.         return -1;

  153.     }

  154. 

  155.     ret = avctx->codec->encode_sub(avctx, buf, buf_size, sub);

  156.     avctx->frame_number++;

  157.     return ret;

  158. }

  159. 

  160. int ff_encode_get_frame(AVCodecContext *avctx, AVFrame *frame)

  161. {

  162.     AVCodecInternal *avci = avctx->internal;

  163. 

  164.     if (avci->draining)

  165.         return AVERROR_EOF;

  166. 

  167.     if (!avci->buffer_frame->buf[0])

  168.         return AVERROR(EAGAIN);

  169. 

  170.     av_frame_move_ref(frame, avci->buffer_frame);

  171. 

  172.     return 0;

  173. }

  174. 

  175. static int encode_simple_internal(AVCodecContext *avctx, AVPacket *avpkt)

  176. {

  177.     AVCodecInternal   *avci = avctx->internal;

  178.     EncodeSimpleContext *es = &avci->es;

  179.     AVFrame          *frame = es->in_frame;

  180.     int got_packet;

  181.     int ret;

  182. 

  183.     if (avci->draining_done)

  184.         return AVERROR_EOF;

  185. 

  186.     if (!frame->buf[0] && !avci->draining) {

  187.         av_frame_unref(frame);

  188.         ret = ff_encode_get_frame(avctx, frame);

  189.         if (ret < 0 && ret != AVERROR_EOF)

  190.             return ret;

  191.     }

  192. 

  193.     if (!frame->buf[0]) {

  194.         if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY ||

  195.               (avci->frame_thread_encoder && avctx->active_thread_type & FF_THREAD_FRAME)))

  196.             return AVERROR_EOF;

  197. 

  198.         // Flushing is signaled with a NULL frame

  199.         frame = NULL;

  200.     }

  201. 

  202.     got_packet = 0;

  203. 

  204.     av_assert0(avctx->codec->encode2);

  205. 

  206.     if (CONFIG_FRAME_THREAD_ENCODER &&

  207.         avci->frame_thread_encoder && (avctx->active_thread_type & FF_THREAD_FRAME))

  208.         /* This might modify frame, but it doesn't matter, because

  209.          * the frame properties used below are not used for video

  210.          * (due to the delay inherent in frame threaded encoding, it makes

  211.          *  no sense to use the properties of the current frame anyway). */

  212.         ret = ff_thread_video_encode_frame(avctx, avpkt, frame, &got_packet);

  213.     else {

  214.         ret = avctx->codec->encode2(avctx, avpkt, frame, &got_packet);

  215.         if (avctx->codec->type == AVMEDIA_TYPE_VIDEO && !ret && got_packet &&

  216.             !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))

  217.             avpkt->pts = avpkt->dts = frame->pts;

  218.     }

  219. 

  220.     av_assert0(ret <= 0);

  221. 

  222.     emms_c();

  223. 

  224.     if (!ret && got_packet) {

  225.         if (avpkt->data) {

  226.             ret = av_packet_make_refcounted(avpkt);

  227.             if (ret < 0)

  228.                 goto end;

  229.         }

  230. 

  231.         if (frame && !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY)) {

  232.             if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {

  233.                 if (avpkt->pts == AV_NOPTS_VALUE)

  234.                     avpkt->pts = frame->pts;

  235.                 if (!avpkt->duration)

  236.                     avpkt->duration = ff_samples_to_time_base(avctx,

  237.                                                               frame->nb_samples);

  238.             }

  239.         }

  240.         if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {

  241.             /* NOTE: if we add any audio encoders which output non-keyframe packets,

  242.              *       this needs to be moved to the encoders, but for now we can do it

  243.              *       here to simplify things */

  244.             avpkt->flags |= AV_PKT_FLAG_KEY;

  245.             avpkt->dts = avpkt->pts;

  246.         }

  247.     }

  248. 

  249.     if (avci->draining && !got_packet)

  250.         avci->draining_done = 1;

  251. 

  252. end:

  253.     if (ret < 0 || !got_packet)

  254.         av_packet_unref(avpkt);

  255. 

  256.     if (frame) {

  257.         if (!ret)

  258.             avctx->frame_number++;

  259.         av_frame_unref(frame);

  260.     }

  261. 

  262.     if (got_packet)

  263.         // Encoders must always return ref-counted buffers.

  264.         // Side-data only packets have no data and can be not ref-counted.

  265.         av_assert0(!avpkt->data || avpkt->buf);

  266. 

  267.     return ret;

  268. }

  269. 

  270. static int encode_simple_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)

  271. {

  272.     int ret;

  273. 

  274.     while (!avpkt->data && !avpkt->side_data) {

  275.         ret = encode_simple_internal(avctx, avpkt);

  276.         if (ret < 0)

  277.             return ret;

  278.     }

  279. 

  280.     return 0;

  281. }

  282. 

  283. static int encode_receive_packet_internal(AVCodecContext *avctx, AVPacket *avpkt)

  284. {

  285.     AVCodecInternal *avci = avctx->internal;

  286.     int ret;

  287. 

  288.     if (avci->draining_done)

  289.         return AVERROR_EOF;

  290. 

  291.     av_assert0(!avpkt->data && !avpkt->side_data);

  292. 

  293.     if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {

  294.         if ((avctx->flags & AV_CODEC_FLAG_PASS1) && avctx->stats_out)

  295.             avctx->stats_out[0] = '\0';

  296.         if (av_image_check_size2(avctx->width, avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx))

  297.             return AVERROR(EINVAL);

  298.     }

  299. 

  300.     if (avctx->codec->receive_packet) {

  301.         ret = avctx->codec->receive_packet(avctx, avpkt);

  302.         if (ret < 0)

  303.             av_packet_unref(avpkt);

  304.         else

  305.             // Encoders must always return ref-counted buffers.

  306.             // Side-data only packets have no data and can be not ref-counted.

  307.             av_assert0(!avpkt->data || avpkt->buf);

  308.     } else

  309.         ret = encode_simple_receive_packet(avctx, avpkt);

  310. 

  311.     if (ret == AVERROR_EOF)

  312.         avci->draining_done = 1;

  313. 

  314.     return ret;

  315. }

  316. 

  317. static int encode_send_frame_internal(AVCodecContext *avctx, const AVFrame *src)

  318. {

  319.     AVCodecInternal *avci = avctx->internal;

  320.     AVFrame *dst = avci->buffer_frame;

  321.     int ret;

  322. 

  323.     if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {

  324.         /* extract audio service type metadata */

  325.         AVFrameSideData *sd = av_frame_get_side_data(src, AV_FRAME_DATA_AUDIO_SERVICE_TYPE);

  326.         if (sd && sd->size >= sizeof(enum AVAudioServiceType))

  327.             avctx->audio_service_type = *(enum AVAudioServiceType*)sd->data;

  328. 

  329.         /* check for valid frame size */

  330.         if (avctx->codec->capabilities & AV_CODEC_CAP_SMALL_LAST_FRAME) {

  331.             if (src->nb_samples > avctx->frame_size) {

  332.                 av_log(avctx, AV_LOG_ERROR, "more samples than frame size\n");

  333.                 return AVERROR(EINVAL);

  334.             }

  335.         } else if (!(avctx->codec->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)) {

  336.             /* if we already got an undersized frame, that must have been the last */

  337.             if (avctx->internal->last_audio_frame) {

  338.                 av_log(avctx, AV_LOG_ERROR, "frame_size (%d) was not respected for a non-last frame\n", avctx->frame_size);

  339.                 return AVERROR(EINVAL);

  340.             }

  341. 

  342.             if (src->nb_samples < avctx->frame_size) {

  343.                 ret = pad_last_frame(avctx, dst, src);

  344.                 if (ret < 0)

  345.                     return ret;

  346. 

  347.                 avctx->internal->last_audio_frame = 1;

  348.             } else if (src->nb_samples > avctx->frame_size) {

  349.                 av_log(avctx, AV_LOG_ERROR, "nb_samples (%d) != frame_size (%d)\n", src->nb_samples, avctx->frame_size);

  350.                 return AVERROR(EINVAL);

  351.             }

  352.         }

  353.     }

  354. 

  355.     if (!dst->data[0]) {

  356.         ret = av_frame_ref(dst, src);

  357.         if (ret < 0)

  358.              return ret;

  359.     }

  360. 

  361.     return 0;

  362. }

  363. 

  364. int attribute_align_arg avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame)

  365. {

  366.     AVCodecInternal *avci = avctx->internal;

  367.     int ret;

  368. 

  369.     if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec))

  370.         return AVERROR(EINVAL);

  371. 

  372.     if (avci->draining)

  373.         return AVERROR_EOF;

  374. 

  375.     if (avci->buffer_frame->data[0])

  376.         return AVERROR(EAGAIN);

  377. 

  378.     if (!frame) {

  379.         avci->draining = 1;

  380.     } else {

  381.         ret = encode_send_frame_internal(avctx, frame);

  382.         if (ret < 0)

  383.             return ret;

  384.     }

  385. 

  386.     if (!avci->buffer_pkt->data && !avci->buffer_pkt->side_data) {

  387.         ret = encode_receive_packet_internal(avctx, avci->buffer_pkt);

  388.         if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)

  389.             return ret;

  390.     }

  391. 

  392.     return 0;

  393. }

  394. 

  395. int attribute_align_arg avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)

  396. {

  397.     AVCodecInternal *avci = avctx->internal;

  398.     int ret;

  399. 

  400.     av_packet_unref(avpkt);

  401. 

  402.     if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec))

  403.         return AVERROR(EINVAL);

  404. 

  405.     if (avci->buffer_pkt->data || avci->buffer_pkt->side_data) {

  406.         av_packet_move_ref(avpkt, avci->buffer_pkt);

  407.     } else {

  408.         ret = encode_receive_packet_internal(avctx, avpkt);

  409.         if (ret < 0)

  410.             return ret;

  411.     }

  412. 

  413.     return 0;

  414. }

  415. 

  416. #if FF_API_OLD_ENCDEC

  417. static int compat_encode(AVCodecContext *avctx, AVPacket *avpkt,

  418.                          int *got_packet, const AVFrame *frame)

  419. {

  420.     AVCodecInternal *avci = avctx->internal;

  421.     AVPacket user_pkt;

  422.     int ret;

  423. 

  424.     *got_packet = 0;

  425. 

  426.     if (frame && avctx->codec->type == AVMEDIA_TYPE_VIDEO) {

  427.         if (frame->format == AV_PIX_FMT_NONE)

  428.             av_log(avctx, AV_LOG_WARNING, "AVFrame.format is not set\n");

  429.         if (frame->width == 0 || frame->height == 0)

  430.             av_log(avctx, AV_LOG_WARNING, "AVFrame.width or height is not set\n");

  431.     }

  432. 

  433.     if (avctx->codec->capabilities & AV_CODEC_CAP_DR1) {

  434.         av_log(avctx, AV_LOG_WARNING, "The deprecated avcodec_encode_* API does not support "

  435.                                       "AV_CODEC_CAP_DR1 encoders\n");

  436.         return AVERROR(ENOSYS);

  437.     }

  438. 

  439.     ret = avcodec_send_frame(avctx, frame);

  440.     if (ret == AVERROR_EOF)

  441.         ret = 0;

  442.     else if (ret == AVERROR(EAGAIN)) {

  443.         /* we fully drain all the output in each encode call, so this should not

  444.          * ever happen */

  445.         return AVERROR_BUG;

  446.     } else if (ret < 0)

  447.         return ret;

  448. 

  449.     av_packet_move_ref(&user_pkt, avpkt);

  450.     while (ret >= 0) {

  451.         ret = avcodec_receive_packet(avctx, avpkt);

  452.         if (ret < 0) {

  453.             if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)

  454.                 ret = 0;

  455.             goto finish;

  456.         }

  457. 

  458.         if (avpkt != avci->compat_encode_packet) {

  459.             if (avpkt->data && user_pkt.data) {

  460.                 if (user_pkt.size >= avpkt->size) {

  461.                     memcpy(user_pkt.data, avpkt->data, avpkt->size);

  462.                     av_buffer_unref(&avpkt->buf);

  463.                     avpkt->buf  = user_pkt.buf;

  464.                     avpkt->data = user_pkt.data;

  465. FF_DISABLE_DEPRECATION_WARNINGS

  466.                     av_init_packet(&user_pkt);

  467. FF_ENABLE_DEPRECATION_WARNINGS

  468.                 } else {

  469.                     av_log(avctx, AV_LOG_ERROR, "Provided packet is too small, needs to be %d\n", avpkt->size);

  470.                     av_packet_unref(avpkt);

  471.                     ret = AVERROR(EINVAL);

  472.                     goto finish;

  473.                 }

  474.             }

  475. 

  476.             *got_packet = 1;

  477.             avpkt = avci->compat_encode_packet;

  478.         } else {

  479.             if (!avci->compat_decode_warned) {

  480.                 av_log(avctx, AV_LOG_WARNING, "The deprecated avcodec_encode_* "

  481.                        "API cannot return all the packets for this encoder. "

  482.                        "Some packets will be dropped. Update your code to the "

  483.                        "new encoding API to fix this.\n");

  484.                 avci->compat_decode_warned = 1;

  485.                 av_packet_unref(avpkt);

  486.             }

  487.         }

  488. 

  489.         if (avci->draining)

  490.             break;

  491.     }

  492. 

  493. finish:

  494.     if (ret < 0)

  495.         av_packet_unref(&user_pkt);

  496. 

  497.     return ret;

  498. }

  499. 

  500. int attribute_align_arg avcodec_encode_audio2(AVCodecContext *avctx,

  501.                                               AVPacket *avpkt,

  502.                                               const AVFrame *frame,

  503.                                               int *got_packet_ptr)

  504. {

  505.     int ret = compat_encode(avctx, avpkt, got_packet_ptr, frame);

  506. 

  507.     if (ret < 0)

  508.         av_packet_unref(avpkt);

  509. 

  510.     return ret;

  511. }

  512. 

  513. int attribute_align_arg avcodec_encode_video2(AVCodecContext *avctx,

  514.                                               AVPacket *avpkt,

  515.                                               const AVFrame *frame,

  516.                                               int *got_packet_ptr)

  517. {

  518.     int ret = compat_encode(avctx, avpkt, got_packet_ptr, frame);

  519. 

  520.     if (ret < 0)

  521.         av_packet_unref(avpkt);

  522. 

  523.     return ret;

  524. }

  525. #endif

  526. 

  527. int ff_encode_preinit(AVCodecContext *avctx)

  528. {

  529.     int i;

  530. #if FF_API_CODED_FRAME

  531. FF_DISABLE_DEPRECATION_WARNINGS

  532.     avctx->coded_frame = av_frame_alloc();

  533.     if (!avctx->coded_frame) {

  534.         return AVERROR(ENOMEM);

  535.     }

  536. FF_ENABLE_DEPRECATION_WARNINGS

  537. #endif

  538. 

  539.     if (avctx->time_base.num <= 0 || avctx->time_base.den <= 0) {

  540.         av_log(avctx, AV_LOG_ERROR, "The encoder timebase is not set.\n");

  541.         return AVERROR(EINVAL);

  542.     }

  543. 

  544.     if (avctx->codec->sample_fmts) {

  545.         for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++) {

  546.             if (avctx->sample_fmt == avctx->codec->sample_fmts[i])

  547.                 break;

  548.             if (avctx->channels == 1 &&

  549.                 av_get_planar_sample_fmt(avctx->sample_fmt) ==

  550.                 av_get_planar_sample_fmt(avctx->codec->sample_fmts[i])) {

  551.                 avctx->sample_fmt = avctx->codec->sample_fmts[i];

  552.                 break;

  553.             }

  554.         }

  555.         if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {

  556.             char buf[128];

  557.             snprintf(buf, sizeof(buf), "%d", avctx->sample_fmt);

  558.             av_log(avctx, AV_LOG_ERROR, "Specified sample format %s is invalid or not supported\n",

  559.                    (char *)av_x_if_null(av_get_sample_fmt_name(avctx->sample_fmt), buf));

  560.             return AVERROR(EINVAL);

  561.         }

  562.     }

  563.     if (avctx->codec->pix_fmts) {

  564.         for (i = 0; avctx->codec->pix_fmts[i] != AV_PIX_FMT_NONE; i++)

  565.             if (avctx->pix_fmt == avctx->codec->pix_fmts[i])

  566.                 break;

  567.         if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_NONE

  568.             && !(avctx->codec_id == AV_CODEC_ID_MJPEG

  569.                  && avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL)) {

  570.             char buf[128];

  571.             snprintf(buf, sizeof(buf), "%d", avctx->pix_fmt);

  572.             av_log(avctx, AV_LOG_ERROR, "Specified pixel format %s is invalid or not supported\n",

  573.                    (char *)av_x_if_null(av_get_pix_fmt_name(avctx->pix_fmt), buf));

  574.             return AVERROR(EINVAL);

  575.         }

  576.         if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ420P ||

  577.             avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ411P ||

  578.             avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ422P ||

  579.             avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ440P ||

  580.             avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ444P)

  581.             avctx->color_range = AVCOL_RANGE_JPEG;

  582.     }

  583.     if (avctx->codec->supported_samplerates) {

  584.         for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)

  585.             if (avctx->sample_rate == avctx->codec->supported_samplerates[i])

  586.                 break;

  587.         if (avctx->codec->supported_samplerates[i] == 0) {

  588.             av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",

  589.                    avctx->sample_rate);

  590.             return AVERROR(EINVAL);

  591.         }

  592.     }

  593.     if (avctx->sample_rate < 0) {

  594.         av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",

  595.                 avctx->sample_rate);

  596.         return AVERROR(EINVAL);

  597.     }

  598.     if (avctx->codec->channel_layouts) {

  599.         if (!avctx->channel_layout) {

  600.             av_log(avctx, AV_LOG_WARNING, "Channel layout not specified\n");

  601.         } else {

  602.             for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)

  603.                 if (avctx->channel_layout == avctx->codec->channel_layouts[i])

  604.                     break;

  605.             if (avctx->codec->channel_layouts[i] == 0) {

  606.                 char buf[512];

  607.                 av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);

  608.                 av_log(avctx, AV_LOG_ERROR, "Specified channel layout '%s' is not supported\n", buf);

  609.                 return AVERROR(EINVAL);

  610.             }

  611.         }

  612.     }

  613.     if (avctx->channel_layout && avctx->channels) {

  614.         int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);

  615.         if (channels != avctx->channels) {

  616.             char buf[512];

  617.             av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);

  618.             av_log(avctx, AV_LOG_ERROR,

  619.                    "Channel layout '%s' with %d channels does not match number of specified channels %d\n",

  620.                    buf, channels, avctx->channels);

  621.             return AVERROR(EINVAL);

  622.         }

  623.     } else if (avctx->channel_layout) {

  624.         avctx->channels = av_get_channel_layout_nb_channels(avctx->channel_layout);

  625.     }

  626.     if (avctx->channels < 0) {

  627.         av_log(avctx, AV_LOG_ERROR, "Specified number of channels %d is not supported\n",

  628.                 avctx->channels);

  629.         return AVERROR(EINVAL);

  630.     }

  631.     if(avctx->codec_type == AVMEDIA_TYPE_VIDEO) {

  632.         const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(avctx->pix_fmt);

  633.         if (    avctx->bits_per_raw_sample < 0

  634.             || (avctx->bits_per_raw_sample > 8 && pixdesc->comp[0].depth <= 8)) {

  635.             av_log(avctx, AV_LOG_WARNING, "Specified bit depth %d not possible with the specified pixel formats depth %d\n",

  636.                 avctx->bits_per_raw_sample, pixdesc->comp[0].depth);

  637.             avctx->bits_per_raw_sample = pixdesc->comp[0].depth;

  638.         }

  639.         if (avctx->width <= 0 || avctx->height <= 0) {

  640.             av_log(avctx, AV_LOG_ERROR, "dimensions not set\n");

  641.             return AVERROR(EINVAL);

  642.         }

  643.     }

  644.     if (   (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)

  645.         && avctx->bit_rate>0 && avctx->bit_rate<1000) {

  646.         av_log(avctx, AV_LOG_WARNING, "Bitrate %"PRId64" is extremely low, maybe you mean %"PRId64"k\n", avctx->bit_rate, avctx->bit_rate);

  647.     }

  648. 

  649.     if (!avctx->rc_initial_buffer_occupancy)

  650.         avctx->rc_initial_buffer_occupancy = avctx->rc_buffer_size * 3LL / 4;

  651. 

  652.     if (avctx->ticks_per_frame && avctx->time_base.num &&

  653.         avctx->ticks_per_frame > INT_MAX / avctx->time_base.num) {

  654.         av_log(avctx, AV_LOG_ERROR,

  655.                "ticks_per_frame %d too large for the timebase %d/%d.",

  656.                avctx->ticks_per_frame,

  657.                avctx->time_base.num,

  658.                avctx->time_base.den);

  659.         return AVERROR(EINVAL);

  660.     }

  661. 

  662.     if (avctx->hw_frames_ctx) {

  663.         AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;

  664.         if (frames_ctx->format != avctx->pix_fmt) {

  665.             av_log(avctx, AV_LOG_ERROR,

  666.                    "Mismatching AVCodecContext.pix_fmt and AVHWFramesContext.format\n");

  667.             return AVERROR(EINVAL);

  668.         }

  669.         if (avctx->sw_pix_fmt != AV_PIX_FMT_NONE &&

  670.             avctx->sw_pix_fmt != frames_ctx->sw_format) {

  671.             av_log(avctx, AV_LOG_ERROR,

  672.                    "Mismatching AVCodecContext.sw_pix_fmt (%s) "

  673.                    "and AVHWFramesContext.sw_format (%s)\n",

  674.                    av_get_pix_fmt_name(avctx->sw_pix_fmt),

  675.                    av_get_pix_fmt_name(frames_ctx->sw_format));

  676.             return AVERROR(EINVAL);

  677.         }

  678.         avctx->sw_pix_fmt = frames_ctx->sw_format;

  679.     }

  680. 

  681.     return 0;

  682. }