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.
94251 Commits
32 Branches
303MB
Tree: d9418aba66
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd9418aba66'
${ noResults }
FFmpeg/libavcodec/cbs_h2645.c

1676 lines
50KB
Raw Blame History 

  1. /*

  2.  * This file is part of FFmpeg.

  3.  *

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

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

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

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

  8.  *

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

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

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

  12.  * Lesser General Public License for more details.

  13.  *

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

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

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

  17.  */

  18. 

  19. #include "libavutil/attributes.h"

  20. #include "libavutil/avassert.h"

  21. 

  22. #include "bytestream.h"

  23. #include "cbs.h"

  24. #include "cbs_internal.h"

  25. #include "cbs_h264.h"

  26. #include "cbs_h265.h"

  27. #include "golomb.h"

  28. #include "h264.h"

  29. #include "h264_sei.h"

  30. #include "h2645_parse.h"

  31. #include "hevc.h"

  32. #include "hevc_sei.h"

  33. 

  34. 

  35. static int cbs_read_ue_golomb(CodedBitstreamContext *ctx, GetBitContext *gbc,

  36.                               const char *name, const int *subscripts,

  37.                               uint32_t *write_to,

  38.                               uint32_t range_min, uint32_t range_max)

  39. {

  40.     uint32_t value;

  41.     int position, i, j;

  42.     unsigned int k;

  43.     char bits[65];

  44. 

  45.     position = get_bits_count(gbc);

  46. 

  47.     for (i = 0; i < 32; i++) {

  48.         if (get_bits_left(gbc) < i + 1) {

  49.             av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid ue-golomb code at "

  50.                    "%s: bitstream ended.\n", name);

  51.             return AVERROR_INVALIDDATA;

  52.         }

  53.         k = get_bits1(gbc);

  54.         bits[i] = k ? '1' : '0';

  55.         if (k)

  56.             break;

  57.     }

  58.     if (i >= 32) {

  59.         av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid ue-golomb code at "

  60.                "%s: more than 31 zeroes.\n", name);

  61.         return AVERROR_INVALIDDATA;

  62.     }

  63.     value = 1;

  64.     for (j = 0; j < i; j++) {

  65.         k = get_bits1(gbc);

  66.         bits[i + j + 1] = k ? '1' : '0';

  67.         value = value << 1 | k;

  68.     }

  69.     bits[i + j + 1] = 0;

  70.     --value;

  71. 

  72.     if (ctx->trace_enable)

  73.         ff_cbs_trace_syntax_element(ctx, position, name, subscripts,

  74.                                     bits, value);

  75. 

  76.     if (value < range_min || value > range_max) {

  77.         av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "

  78.                "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",

  79.                name, value, range_min, range_max);

  80.         return AVERROR_INVALIDDATA;

  81.     }

  82. 

  83.     *write_to = value;

  84.     return 0;

  85. }

  86. 

  87. static int cbs_read_se_golomb(CodedBitstreamContext *ctx, GetBitContext *gbc,

  88.                               const char *name, const int *subscripts,

  89.                               int32_t *write_to,

  90.                               int32_t range_min, int32_t range_max)

  91. {

  92.     int32_t value;

  93.     int position, i, j;

  94.     unsigned int k;

  95.     uint32_t v;

  96.     char bits[65];

  97. 

  98.     position = get_bits_count(gbc);

  99. 

  100.     for (i = 0; i < 32; i++) {

  101.         if (get_bits_left(gbc) < i + 1) {

  102.             av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid se-golomb code at "

  103.                    "%s: bitstream ended.\n", name);

  104.             return AVERROR_INVALIDDATA;

  105.         }

  106.         k = get_bits1(gbc);

  107.         bits[i] = k ? '1' : '0';

  108.         if (k)

  109.             break;

  110.     }

  111.     if (i >= 32) {

  112.         av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid se-golomb code at "

  113.                "%s: more than 31 zeroes.\n", name);

  114.         return AVERROR_INVALIDDATA;

  115.     }

  116.     v = 1;

  117.     for (j = 0; j < i; j++) {

  118.         k = get_bits1(gbc);

  119.         bits[i + j + 1] = k ? '1' : '0';

  120.         v = v << 1 | k;

  121.     }

  122.     bits[i + j + 1] = 0;

  123.     if (v & 1)

  124.         value = -(int32_t)(v / 2);

  125.     else

  126.         value = v / 2;

  127. 

  128.     if (ctx->trace_enable)

  129.         ff_cbs_trace_syntax_element(ctx, position, name, subscripts,

  130.                                     bits, value);

  131. 

  132.     if (value < range_min || value > range_max) {

  133.         av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "

  134.                "%"PRId32", but must be in [%"PRId32",%"PRId32"].\n",

  135.                name, value, range_min, range_max);

  136.         return AVERROR_INVALIDDATA;

  137.     }

  138. 

  139.     *write_to = value;

  140.     return 0;

  141. }

  142. 

  143. static int cbs_write_ue_golomb(CodedBitstreamContext *ctx, PutBitContext *pbc,

  144.                                const char *name, const int *subscripts,

  145.                                uint32_t value,

  146.                                uint32_t range_min, uint32_t range_max)

  147. {

  148.     int len;

  149. 

  150.     if (value < range_min || value > range_max) {

  151.         av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "

  152.                "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",

  153.                name, value, range_min, range_max);

  154.         return AVERROR_INVALIDDATA;

  155.     }

  156.     av_assert0(value != UINT32_MAX);

  157. 

  158.     len = av_log2(value + 1);

  159.     if (put_bits_left(pbc) < 2 * len + 1)

  160.         return AVERROR(ENOSPC);

  161. 

  162.     if (ctx->trace_enable) {

  163.         char bits[65];

  164.         int i;

  165. 

  166.         for (i = 0; i < len; i++)

  167.             bits[i] = '0';

  168.         bits[len] = '1';

  169.         for (i = 0; i < len; i++)

  170.             bits[len + i + 1] = (value + 1) >> (len - i - 1) & 1 ? '1' : '0';

  171.         bits[len + len + 1] = 0;

  172. 

  173.         ff_cbs_trace_syntax_element(ctx, put_bits_count(pbc),

  174.                                     name, subscripts, bits, value);

  175.     }

  176. 

  177.     put_bits(pbc, len, 0);

  178.     if (len + 1 < 32)

  179.         put_bits(pbc, len + 1, value + 1);

  180.     else

  181.         put_bits32(pbc, value + 1);

  182. 

  183.     return 0;

  184. }

  185. 

  186. static int cbs_write_se_golomb(CodedBitstreamContext *ctx, PutBitContext *pbc,

  187.                                const char *name, const int *subscripts,

  188.                                int32_t value,

  189.                                int32_t range_min, int32_t range_max)

  190. {

  191.     int len;

  192.     uint32_t uvalue;

  193. 

  194.     if (value < range_min || value > range_max) {

  195.         av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "

  196.                "%"PRId32", but must be in [%"PRId32",%"PRId32"].\n",

  197.                name, value, range_min, range_max);

  198.         return AVERROR_INVALIDDATA;

  199.     }

  200.     av_assert0(value != INT32_MIN);

  201. 

  202.     if (value == 0)

  203.         uvalue = 0;

  204.     else if (value > 0)

  205.         uvalue = 2 * (uint32_t)value - 1;

  206.     else

  207.         uvalue = 2 * (uint32_t)-value;

  208. 

  209.     len = av_log2(uvalue + 1);

  210.     if (put_bits_left(pbc) < 2 * len + 1)

  211.         return AVERROR(ENOSPC);

  212. 

  213.     if (ctx->trace_enable) {

  214.         char bits[65];

  215.         int i;

  216. 

  217.         for (i = 0; i < len; i++)

  218.             bits[i] = '0';

  219.         bits[len] = '1';

  220.         for (i = 0; i < len; i++)

  221.             bits[len + i + 1] = (uvalue + 1) >> (len - i - 1) & 1 ? '1' : '0';

  222.         bits[len + len + 1] = 0;

  223. 

  224.         ff_cbs_trace_syntax_element(ctx, put_bits_count(pbc),

  225.                                     name, subscripts, bits, value);

  226.     }

  227. 

  228.     put_bits(pbc, len, 0);

  229.     if (len + 1 < 32)

  230.         put_bits(pbc, len + 1, uvalue + 1);

  231.     else

  232.         put_bits32(pbc, uvalue + 1);

  233. 

  234.     return 0;

  235. }

  236. 

  237. #define HEADER(name) do { \

  238.         ff_cbs_trace_header(ctx, name); \

  239.     } while (0)

  240. 

  241. #define CHECK(call) do { \

  242.         err = (call); \

  243.         if (err < 0) \

  244.             return err; \

  245.     } while (0)

  246. 

  247. #define FUNC_NAME(rw, codec, name) cbs_ ## codec ## _ ## rw ## _ ## name

  248. #define FUNC_H264(rw, name) FUNC_NAME(rw, h264, name)

  249. #define FUNC_H265(rw, name) FUNC_NAME(rw, h265, name)

  250. 

  251. #define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__ }) : NULL)

  252. 

  253. #define u(width, name, range_min, range_max) \

  254.         xu(width, name, current->name, range_min, range_max, 0)

  255. #define ub(width, name) \

  256.         xu(width, name, current->name, 0, MAX_UINT_BITS(width), 0)

  257. #define flag(name) ub(1, name)

  258. #define ue(name, range_min, range_max) \

  259.         xue(name, current->name, range_min, range_max, 0)

  260. #define i(width, name, range_min, range_max) \

  261.         xi(width, name, current->name, range_min, range_max, 0)

  262. #define ib(width, name) \

  263.         xi(width, name, current->name, MIN_INT_BITS(width), MAX_INT_BITS(width), 0)

  264. #define se(name, range_min, range_max) \

  265.         xse(name, current->name, range_min, range_max, 0)

  266. 

  267. #define us(width, name, range_min, range_max, subs, ...) \

  268.         xu(width, name, current->name, range_min, range_max, subs, __VA_ARGS__)

  269. #define ubs(width, name, subs, ...) \

  270.         xu(width, name, current->name, 0, MAX_UINT_BITS(width), subs, __VA_ARGS__)

  271. #define flags(name, subs, ...) \

  272.         xu(1, name, current->name, 0, 1, subs, __VA_ARGS__)

  273. #define ues(name, range_min, range_max, subs, ...) \

  274.         xue(name, current->name, range_min, range_max, subs, __VA_ARGS__)

  275. #define is(width, name, range_min, range_max, subs, ...) \

  276.         xi(width, name, current->name, range_min, range_max, subs, __VA_ARGS__)

  277. #define ibs(width, name, subs, ...) \

  278.         xi(width, name, current->name, MIN_INT_BITS(width), MAX_INT_BITS(width), subs, __VA_ARGS__)

  279. #define ses(name, range_min, range_max, subs, ...) \

  280.         xse(name, current->name, range_min, range_max, subs, __VA_ARGS__)

  281. 

  282. #define fixed(width, name, value) do { \

  283.         av_unused uint32_t fixed_value = value; \

  284.         xu(width, name, fixed_value, value, value, 0); \

  285.     } while (0)

  286. 

  287. 

  288. #define READ

  289. #define READWRITE read

  290. #define RWContext GetBitContext

  291. 

  292. #define xu(width, name, var, range_min, range_max, subs, ...) do { \

  293.         uint32_t value = range_min; \

  294.         CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \

  295.                                    SUBSCRIPTS(subs, __VA_ARGS__), \

  296.                                    &value, range_min, range_max)); \

  297.         var = value; \

  298.     } while (0)

  299. #define xue(name, var, range_min, range_max, subs, ...) do { \

  300.         uint32_t value = range_min; \

  301.         CHECK(cbs_read_ue_golomb(ctx, rw, #name, \

  302.                                  SUBSCRIPTS(subs, __VA_ARGS__), \

  303.                                  &value, range_min, range_max)); \

  304.         var = value; \

  305.     } while (0)

  306. #define xi(width, name, var, range_min, range_max, subs, ...) do { \

  307.         int32_t value = range_min; \

  308.         CHECK(ff_cbs_read_signed(ctx, rw, width, #name, \

  309.                                  SUBSCRIPTS(subs, __VA_ARGS__), \

  310.                                  &value, range_min, range_max)); \

  311.         var = value; \

  312.     } while (0)

  313. #define xse(name, var, range_min, range_max, subs, ...) do { \

  314.         int32_t value = range_min; \

  315.         CHECK(cbs_read_se_golomb(ctx, rw, #name, \

  316.                                  SUBSCRIPTS(subs, __VA_ARGS__), \

  317.                                  &value, range_min, range_max)); \

  318.         var = value; \

  319.     } while (0)

  320. 

  321. 

  322. #define infer(name, value) do { \

  323.         current->name = value; \

  324.     } while (0)

  325. 

  326. static int cbs_h2645_read_more_rbsp_data(GetBitContext *gbc)

  327. {

  328.     int bits_left = get_bits_left(gbc);

  329.     if (bits_left > 8)

  330.         return 1;

  331.     if (show_bits(gbc, bits_left) == 1 << (bits_left - 1))

  332.         return 0;

  333.     return 1;

  334. }

  335. 

  336. #define more_rbsp_data(var) ((var) = cbs_h2645_read_more_rbsp_data(rw))

  337. 

  338. #define byte_alignment(rw) (get_bits_count(rw) % 8)

  339. 

  340. #define allocate(name, size) do { \

  341.         name ## _ref = av_buffer_allocz(size + \

  342.                                         AV_INPUT_BUFFER_PADDING_SIZE); \

  343.         if (!name ## _ref) \

  344.             return AVERROR(ENOMEM); \

  345.         name = name ## _ref->data; \

  346.     } while (0)

  347. 

  348. #define FUNC(name) FUNC_H264(READWRITE, name)

  349. #include "cbs_h264_syntax_template.c"

  350. #undef FUNC

  351. 

  352. #define FUNC(name) FUNC_H265(READWRITE, name)

  353. #include "cbs_h265_syntax_template.c"

  354. #undef FUNC

  355. 

  356. #undef READ

  357. #undef READWRITE

  358. #undef RWContext

  359. #undef xu

  360. #undef xi

  361. #undef xue

  362. #undef xse

  363. #undef infer

  364. #undef more_rbsp_data

  365. #undef byte_alignment

  366. #undef allocate

  367. 

  368. 

  369. #define WRITE

  370. #define READWRITE write

  371. #define RWContext PutBitContext

  372. 

  373. #define xu(width, name, var, range_min, range_max, subs, ...) do { \

  374.         uint32_t value = var; \

  375.         CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \

  376.                                     SUBSCRIPTS(subs, __VA_ARGS__), \

  377.                                     value, range_min, range_max)); \

  378.     } while (0)

  379. #define xue(name, var, range_min, range_max, subs, ...) do { \

  380.         uint32_t value = var; \

  381.         CHECK(cbs_write_ue_golomb(ctx, rw, #name, \

  382.                                   SUBSCRIPTS(subs, __VA_ARGS__), \

  383.                                   value, range_min, range_max)); \

  384.     } while (0)

  385. #define xi(width, name, var, range_min, range_max, subs, ...) do { \

  386.         int32_t value = var; \

  387.         CHECK(ff_cbs_write_signed(ctx, rw, width, #name, \

  388.                                   SUBSCRIPTS(subs, __VA_ARGS__), \

  389.                                   value, range_min, range_max)); \

  390.     } while (0)

  391. #define xse(name, var, range_min, range_max, subs, ...) do { \

  392.         int32_t value = var; \

  393.         CHECK(cbs_write_se_golomb(ctx, rw, #name, \

  394.                                   SUBSCRIPTS(subs, __VA_ARGS__), \

  395.                                   value, range_min, range_max)); \

  396.     } while (0)

  397. 

  398. #define infer(name, value) do { \

  399.         if (current->name != (value)) { \

  400.             av_log(ctx->log_ctx, AV_LOG_WARNING, "Warning: " \

  401.                    "%s does not match inferred value: " \

  402.                    "%"PRId64", but should be %"PRId64".\n", \

  403.                    #name, (int64_t)current->name, (int64_t)(value)); \

  404.         } \

  405.     } while (0)

  406. 

  407. #define more_rbsp_data(var) (var)

  408. 

  409. #define byte_alignment(rw) (put_bits_count(rw) % 8)

  410. 

  411. #define allocate(name, size) do { \

  412.         if (!name) { \

  413.             av_log(ctx->log_ctx, AV_LOG_ERROR, "%s must be set " \

  414.                    "for writing.\n", #name); \

  415.             return AVERROR_INVALIDDATA; \

  416.         } \

  417.     } while (0)

  418. 

  419. #define FUNC(name) FUNC_H264(READWRITE, name)

  420. #include "cbs_h264_syntax_template.c"

  421. #undef FUNC

  422. 

  423. #define FUNC(name) FUNC_H265(READWRITE, name)

  424. #include "cbs_h265_syntax_template.c"

  425. #undef FUNC

  426. 

  427. #undef WRITE

  428. #undef READWRITE

  429. #undef RWContext

  430. #undef xu

  431. #undef xi

  432. #undef xue

  433. #undef xse

  434. #undef u

  435. #undef i

  436. #undef flag

  437. #undef ue

  438. #undef se

  439. #undef infer

  440. #undef more_rbsp_data

  441. #undef byte_alignment

  442. #undef allocate

  443. 

  444. 

  445. static void cbs_h264_free_pps(void *unit, uint8_t *content)

  446. {

  447.     H264RawPPS *pps = (H264RawPPS*)content;

  448.     av_buffer_unref(&pps->slice_group_id_ref);

  449.     av_freep(&content);

  450. }

  451. 

  452. static void cbs_h264_free_sei_payload(H264RawSEIPayload *payload)

  453. {

  454.     switch (payload->payload_type) {

  455.     case H264_SEI_TYPE_BUFFERING_PERIOD:

  456.     case H264_SEI_TYPE_PIC_TIMING:

  457.     case H264_SEI_TYPE_PAN_SCAN_RECT:

  458.     case H264_SEI_TYPE_RECOVERY_POINT:

  459.     case H264_SEI_TYPE_DISPLAY_ORIENTATION:

  460.     case H264_SEI_TYPE_MASTERING_DISPLAY_COLOUR_VOLUME:

  461.     case H264_SEI_TYPE_ALTERNATIVE_TRANSFER:

  462.         break;

  463.     case H264_SEI_TYPE_USER_DATA_REGISTERED:

  464.         av_buffer_unref(&payload->payload.user_data_registered.data_ref);

  465.         break;

  466.     case H264_SEI_TYPE_USER_DATA_UNREGISTERED:

  467.         av_buffer_unref(&payload->payload.user_data_unregistered.data_ref);

  468.         break;

  469.     default:

  470.         av_buffer_unref(&payload->payload.other.data_ref);

  471.         break;

  472.     }

  473. }

  474. 

  475. static void cbs_h264_free_sei(void *unit, uint8_t *content)

  476. {

  477.     H264RawSEI *sei = (H264RawSEI*)content;

  478.     int i;

  479.     for (i = 0; i < sei->payload_count; i++)

  480.         cbs_h264_free_sei_payload(&sei->payload[i]);

  481.     av_freep(&content);

  482. }

  483. 

  484. static void cbs_h264_free_slice(void *unit, uint8_t *content)

  485. {

  486.     H264RawSlice *slice = (H264RawSlice*)content;

  487.     av_buffer_unref(&slice->data_ref);

  488.     av_freep(&content);

  489. }

  490. 

  491. static void cbs_h265_free_vps(void *unit, uint8_t *content)

  492. {

  493.     H265RawVPS *vps = (H265RawVPS*)content;

  494.     av_buffer_unref(&vps->extension_data.data_ref);

  495.     av_freep(&content);

  496. }

  497. 

  498. static void cbs_h265_free_sps(void *unit, uint8_t *content)

  499. {

  500.     H265RawSPS *sps = (H265RawSPS*)content;

  501.     av_buffer_unref(&sps->extension_data.data_ref);

  502.     av_freep(&content);

  503. }

  504. 

  505. static void cbs_h265_free_pps(void *unit, uint8_t *content)

  506. {

  507.     H265RawPPS *pps = (H265RawPPS*)content;

  508.     av_buffer_unref(&pps->extension_data.data_ref);

  509.     av_freep(&content);

  510. }

  511. 

  512. static void cbs_h265_free_slice(void *unit, uint8_t *content)

  513. {

  514.     H265RawSlice *slice = (H265RawSlice*)content;

  515.     av_buffer_unref(&slice->data_ref);

  516.     av_freep(&content);

  517. }

  518. 

  519. static void cbs_h265_free_sei_payload(H265RawSEIPayload *payload)

  520. {

  521.     switch (payload->payload_type) {

  522.     case HEVC_SEI_TYPE_BUFFERING_PERIOD:

  523.     case HEVC_SEI_TYPE_PICTURE_TIMING:

  524.     case HEVC_SEI_TYPE_PAN_SCAN_RECT:

  525.     case HEVC_SEI_TYPE_RECOVERY_POINT:

  526.     case HEVC_SEI_TYPE_DISPLAY_ORIENTATION:

  527.     case HEVC_SEI_TYPE_ACTIVE_PARAMETER_SETS:

  528.     case HEVC_SEI_TYPE_DECODED_PICTURE_HASH:

  529.     case HEVC_SEI_TYPE_TIME_CODE:

  530.     case HEVC_SEI_TYPE_MASTERING_DISPLAY_INFO:

  531.     case HEVC_SEI_TYPE_CONTENT_LIGHT_LEVEL_INFO:

  532.     case HEVC_SEI_TYPE_ALTERNATIVE_TRANSFER_CHARACTERISTICS:

  533.         break;

  534.     case HEVC_SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35:

  535.         av_buffer_unref(&payload->payload.user_data_registered.data_ref);

  536.         break;

  537.     case HEVC_SEI_TYPE_USER_DATA_UNREGISTERED:

  538.         av_buffer_unref(&payload->payload.user_data_unregistered.data_ref);

  539.         break;

  540.     default:

  541.         av_buffer_unref(&payload->payload.other.data_ref);

  542.         break;

  543.     }

  544. }

  545. 

  546. static void cbs_h265_free_sei(void *unit, uint8_t *content)

  547. {

  548.     H265RawSEI *sei = (H265RawSEI*)content;

  549.     int i;

  550.     for (i = 0; i < sei->payload_count; i++)

  551.         cbs_h265_free_sei_payload(&sei->payload[i]);

  552.     av_freep(&content);

  553. }

  554. 

  555. static int cbs_h2645_fragment_add_nals(CodedBitstreamContext *ctx,

  556.                                        CodedBitstreamFragment *frag,

  557.                                        const H2645Packet *packet)

  558. {

  559.     int err, i;

  560. 

  561.     for (i = 0; i < packet->nb_nals; i++) {

  562.         const H2645NAL *nal = &packet->nals[i];

  563.         AVBufferRef *ref;

  564.         size_t size = nal->size;

  565. 

  566.         // Remove trailing zeroes.

  567.         while (size > 0 && nal->data[size - 1] == 0)

  568.             --size;

  569.         av_assert0(size > 0);

  570. 

  571.         ref = (nal->data == nal->raw_data) ? frag->data_ref

  572.                                            : packet->rbsp.rbsp_buffer_ref;

  573. 

  574.         err = ff_cbs_insert_unit_data(ctx, frag, -1, nal->type,

  575.                             (uint8_t*)nal->data, size, ref);

  576.         if (err < 0)

  577.             return err;

  578.     }

  579. 

  580.     return 0;

  581. }

  582. 

  583. static int cbs_h2645_split_fragment(CodedBitstreamContext *ctx,

  584.                                     CodedBitstreamFragment *frag,

  585.                                     int header)

  586. {

  587.     enum AVCodecID codec_id = ctx->codec->codec_id;

  588.     CodedBitstreamH2645Context *priv = ctx->priv_data;

  589.     GetByteContext gbc;

  590.     int err;

  591. 

  592.     av_assert0(frag->data && frag->nb_units == 0);

  593.     if (frag->data_size == 0)

  594.         return 0;

  595. 

  596.     if (header && frag->data[0] && codec_id == AV_CODEC_ID_H264) {

  597.         // AVCC header.

  598.         size_t size, start, end;

  599.         int i, count, version;

  600. 

  601.         priv->mp4 = 1;

  602. 

  603.         bytestream2_init(&gbc, frag->data, frag->data_size);

  604. 

  605.         if (bytestream2_get_bytes_left(&gbc) < 6)

  606.             return AVERROR_INVALIDDATA;

  607. 

  608.         version = bytestream2_get_byte(&gbc);

  609.         if (version != 1) {

  610.             av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid AVCC header: "

  611.                    "first byte %u.", version);

  612.             return AVERROR_INVALIDDATA;

  613.         }

  614. 

  615.         bytestream2_skip(&gbc, 3);

  616.         priv->nal_length_size = (bytestream2_get_byte(&gbc) & 3) + 1;

  617. 

  618.         // SPS array.

  619.         count = bytestream2_get_byte(&gbc) & 0x1f;

  620.         start = bytestream2_tell(&gbc);

  621.         for (i = 0; i < count; i++) {

  622.             if (bytestream2_get_bytes_left(&gbc) < 2 * (count - i))

  623.                 return AVERROR_INVALIDDATA;

  624.             size = bytestream2_get_be16(&gbc);

  625.             if (bytestream2_get_bytes_left(&gbc) < size)

  626.                 return AVERROR_INVALIDDATA;

  627.             bytestream2_skip(&gbc, size);

  628.         }

  629.         end = bytestream2_tell(&gbc);

  630. 

  631.         err = ff_h2645_packet_split(&priv->read_packet,

  632.                                     frag->data + start, end - start,

  633.                                     ctx->log_ctx, 1, 2, AV_CODEC_ID_H264, 1, 1);

  634.         if (err < 0) {

  635.             av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to split AVCC SPS array.\n");

  636.             return err;

  637.         }

  638.         err = cbs_h2645_fragment_add_nals(ctx, frag, &priv->read_packet);

  639.         if (err < 0)

  640.             return err;

  641. 

  642.         // PPS array.

  643.         count = bytestream2_get_byte(&gbc);

  644.         start = bytestream2_tell(&gbc);

  645.         for (i = 0; i < count; i++) {

  646.             if (bytestream2_get_bytes_left(&gbc) < 2 * (count - i))

  647.                 return AVERROR_INVALIDDATA;

  648.             size = bytestream2_get_be16(&gbc);

  649.             if (bytestream2_get_bytes_left(&gbc) < size)

  650.                 return AVERROR_INVALIDDATA;

  651.             bytestream2_skip(&gbc, size);

  652.         }

  653.         end = bytestream2_tell(&gbc);

  654. 

  655.         err = ff_h2645_packet_split(&priv->read_packet,

  656.                                     frag->data + start, end - start,

  657.                                     ctx->log_ctx, 1, 2, AV_CODEC_ID_H264, 1, 1);

  658.         if (err < 0) {

  659.             av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to split AVCC PPS array.\n");

  660.             return err;

  661.         }

  662.         err = cbs_h2645_fragment_add_nals(ctx, frag, &priv->read_packet);

  663.         if (err < 0)

  664.             return err;

  665. 

  666.         if (bytestream2_get_bytes_left(&gbc) > 0) {

  667.             av_log(ctx->log_ctx, AV_LOG_WARNING, "%u bytes left at end of AVCC "

  668.                    "header.\n", bytestream2_get_bytes_left(&gbc));

  669.         }

  670. 

  671.     } else if (header && frag->data[0] && codec_id == AV_CODEC_ID_HEVC) {

  672.         // HVCC header.

  673.         size_t size, start, end;

  674.         int i, j, nb_arrays, nal_unit_type, nb_nals, version;

  675. 

  676.         priv->mp4 = 1;

  677. 

  678.         bytestream2_init(&gbc, frag->data, frag->data_size);

  679. 

  680.         if (bytestream2_get_bytes_left(&gbc) < 23)

  681.             return AVERROR_INVALIDDATA;

  682. 

  683.         version = bytestream2_get_byte(&gbc);

  684.         if (version != 1) {

  685.             av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid HVCC header: "

  686.                    "first byte %u.", version);

  687.             return AVERROR_INVALIDDATA;

  688.         }

  689. 

  690.         bytestream2_skip(&gbc, 20);

  691.         priv->nal_length_size = (bytestream2_get_byte(&gbc) & 3) + 1;

  692. 

  693.         nb_arrays = bytestream2_get_byte(&gbc);

  694.         for (i = 0; i < nb_arrays; i++) {

  695.             nal_unit_type = bytestream2_get_byte(&gbc) & 0x3f;

  696.             nb_nals = bytestream2_get_be16(&gbc);

  697. 

  698.             start = bytestream2_tell(&gbc);

  699.             for (j = 0; j < nb_nals; j++) {

  700.                 if (bytestream2_get_bytes_left(&gbc) < 2)

  701.                     return AVERROR_INVALIDDATA;

  702.                 size = bytestream2_get_be16(&gbc);

  703.                 if (bytestream2_get_bytes_left(&gbc) < size)

  704.                     return AVERROR_INVALIDDATA;

  705.                 bytestream2_skip(&gbc, size);

  706.             }

  707.             end = bytestream2_tell(&gbc);

  708. 

  709.             err = ff_h2645_packet_split(&priv->read_packet,

  710.                                         frag->data + start, end - start,

  711.                                         ctx->log_ctx, 1, 2, AV_CODEC_ID_HEVC, 1, 1);

  712.             if (err < 0) {

  713.                 av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to split "

  714.                        "HVCC array %d (%d NAL units of type %d).\n",

  715.                        i, nb_nals, nal_unit_type);

  716.                 return err;

  717.             }

  718.             err = cbs_h2645_fragment_add_nals(ctx, frag, &priv->read_packet);

  719.             if (err < 0)

  720.                 return err;

  721.         }

  722. 

  723.     } else {

  724.         // Annex B, or later MP4 with already-known parameters.

  725. 

  726.         err = ff_h2645_packet_split(&priv->read_packet,

  727.                                     frag->data, frag->data_size,

  728.                                     ctx->log_ctx,

  729.                                     priv->mp4, priv->nal_length_size,

  730.                                     codec_id, 1, 1);

  731.         if (err < 0)

  732.             return err;

  733. 

  734.         err = cbs_h2645_fragment_add_nals(ctx, frag, &priv->read_packet);

  735.         if (err < 0)

  736.             return err;

  737.     }

  738. 

  739.     return 0;

  740. }

  741. 

  742. #define cbs_h2645_replace_ps(h26n, ps_name, ps_var, id_element) \

  743. static int cbs_h26 ## h26n ## _replace_ ## ps_var(CodedBitstreamContext *ctx, \

  744.                                                   CodedBitstreamUnit *unit)  \

  745. { \

  746.     CodedBitstreamH26 ## h26n ## Context *priv = ctx->priv_data; \

  747.     H26 ## h26n ## Raw ## ps_name *ps_var = unit->content; \

  748.     unsigned int id = ps_var->id_element; \

  749.     if (id > FF_ARRAY_ELEMS(priv->ps_var)) { \

  750.         av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid " #ps_name \

  751.                " id : %d.\n", id); \

  752.         return AVERROR_INVALIDDATA; \

  753.     } \

  754.     if (priv->ps_var[id] == priv->active_ ## ps_var) \

  755.         priv->active_ ## ps_var = NULL ; \

  756.     av_buffer_unref(&priv->ps_var ## _ref[id]); \

  757.     if (unit->content_ref) \

  758.         priv->ps_var ## _ref[id] = av_buffer_ref(unit->content_ref); \

  759.     else \

  760.         priv->ps_var ## _ref[id] = av_buffer_alloc(sizeof(*ps_var)); \

  761.     if (!priv->ps_var ## _ref[id]) \

  762.         return AVERROR(ENOMEM); \

  763.     priv->ps_var[id] = (H26 ## h26n ## Raw ## ps_name *)priv->ps_var ## _ref[id]->data; \

  764.     if (!unit->content_ref) \

  765.         memcpy(priv->ps_var[id], ps_var, sizeof(*ps_var)); \

  766.     return 0; \

  767. }

  768. 

  769. cbs_h2645_replace_ps(4, SPS, sps, seq_parameter_set_id)

  770. cbs_h2645_replace_ps(4, PPS, pps, pic_parameter_set_id)

  771. cbs_h2645_replace_ps(5, VPS, vps, vps_video_parameter_set_id)

  772. cbs_h2645_replace_ps(5, SPS, sps, sps_seq_parameter_set_id)

  773. cbs_h2645_replace_ps(5, PPS, pps, pps_pic_parameter_set_id)

  774. 

  775. static int cbs_h264_read_nal_unit(CodedBitstreamContext *ctx,

  776.                                   CodedBitstreamUnit *unit)

  777. {

  778.     GetBitContext gbc;

  779.     int err;

  780. 

  781.     err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);

  782.     if (err < 0)

  783.         return err;

  784. 

  785.     switch (unit->type) {

  786.     case H264_NAL_SPS:

  787.         {

  788.             H264RawSPS *sps;

  789. 

  790.             err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*sps), NULL);

  791.             if (err < 0)

  792.                 return err;

  793.             sps = unit->content;

  794. 

  795.             err = cbs_h264_read_sps(ctx, &gbc, sps);

  796.             if (err < 0)

  797.                 return err;

  798. 

  799.             err = cbs_h264_replace_sps(ctx, unit);

  800.             if (err < 0)

  801.                 return err;

  802.         }

  803.         break;

  804. 

  805.     case H264_NAL_SPS_EXT:

  806.         {

  807.             err = ff_cbs_alloc_unit_content(ctx, unit,

  808.                                             sizeof(H264RawSPSExtension),

  809.                                             NULL);

  810.             if (err < 0)

  811.                 return err;

  812. 

  813.             err = cbs_h264_read_sps_extension(ctx, &gbc, unit->content);

  814.             if (err < 0)

  815.                 return err;

  816.         }

  817.         break;

  818. 

  819.     case H264_NAL_PPS:

  820.         {

  821.             H264RawPPS *pps;

  822. 

  823.             err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*pps),

  824.                                             &cbs_h264_free_pps);

  825.             if (err < 0)

  826.                 return err;

  827.             pps = unit->content;

  828. 

  829.             err = cbs_h264_read_pps(ctx, &gbc, pps);

  830.             if (err < 0)

  831.                 return err;

  832. 

  833.             err = cbs_h264_replace_pps(ctx, unit);

  834.             if (err < 0)

  835.                 return err;

  836.         }

  837.         break;

  838. 

  839.     case H264_NAL_SLICE:

  840.     case H264_NAL_IDR_SLICE:

  841.     case H264_NAL_AUXILIARY_SLICE:

  842.         {

  843.             H264RawSlice *slice;

  844.             int pos, len;

  845. 

  846.             err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*slice),

  847.                                             &cbs_h264_free_slice);

  848.             if (err < 0)

  849.                 return err;

  850.             slice = unit->content;

  851. 

  852.             err = cbs_h264_read_slice_header(ctx, &gbc, &slice->header);

  853.             if (err < 0)

  854.                 return err;

  855. 

  856.             pos = get_bits_count(&gbc);

  857.             len = unit->data_size;

  858.             if (!unit->data[len - 1]) {

  859.                 int z;

  860.                 for (z = 0; z < len && !unit->data[len - z - 1]; z++);

  861.                 av_log(ctx->log_ctx, AV_LOG_DEBUG, "Deleted %d trailing zeroes "

  862.                        "from slice data.\n", z);

  863.                 len -= z;

  864.             }

  865. 

  866.             slice->data_size = len - pos / 8;

  867.             slice->data_ref  = av_buffer_ref(unit->data_ref);

  868.             if (!slice->data_ref)

  869.                 return AVERROR(ENOMEM);

  870.             slice->data = unit->data + pos / 8;

  871.             slice->data_bit_start = pos % 8;

  872.         }

  873.         break;

  874. 

  875.     case H264_NAL_AUD:

  876.         {

  877.             err = ff_cbs_alloc_unit_content(ctx, unit,

  878.                                             sizeof(H264RawAUD), NULL);

  879.             if (err < 0)

  880.                 return err;

  881. 

  882.             err = cbs_h264_read_aud(ctx, &gbc, unit->content);

  883.             if (err < 0)

  884.                 return err;

  885.         }

  886.         break;

  887. 

  888.     case H264_NAL_SEI:

  889.         {

  890.             err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(H264RawSEI),

  891.                                             &cbs_h264_free_sei);

  892.             if (err < 0)

  893.                 return err;

  894. 

  895.             err = cbs_h264_read_sei(ctx, &gbc, unit->content);

  896.             if (err < 0)

  897.                 return err;

  898.         }

  899.         break;

  900. 

  901.     case H264_NAL_FILLER_DATA:

  902.         {

  903.             err = ff_cbs_alloc_unit_content(ctx, unit,

  904.                                             sizeof(H264RawFiller), NULL);

  905.             if (err < 0)

  906.                 return err;

  907. 

  908.             err = cbs_h264_read_filler(ctx, &gbc, unit->content);

  909.             if (err < 0)

  910.                 return err;

  911.         }

  912.         break;

  913. 

  914.     case H264_NAL_END_SEQUENCE:

  915.     case H264_NAL_END_STREAM:

  916.         {

  917.             err = ff_cbs_alloc_unit_content(ctx, unit,

  918.                                             sizeof(H264RawNALUnitHeader),

  919.                                             NULL);

  920.             if (err < 0)

  921.                 return err;

  922. 

  923.             err = (unit->type == H264_NAL_END_SEQUENCE ?

  924.                    cbs_h264_read_end_of_sequence :

  925.                    cbs_h264_read_end_of_stream)(ctx, &gbc, unit->content);

  926.             if (err < 0)

  927.                 return err;

  928.         }

  929.         break;

  930. 

  931.     default:

  932.         return AVERROR(ENOSYS);

  933.     }

  934. 

  935.     return 0;

  936. }

  937. 

  938. static int cbs_h265_read_nal_unit(CodedBitstreamContext *ctx,

  939.                                   CodedBitstreamUnit *unit)

  940. {

  941.     GetBitContext gbc;

  942.     int err;

  943. 

  944.     err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);

  945.     if (err < 0)

  946.         return err;

  947. 

  948.     switch (unit->type) {

  949.     case HEVC_NAL_VPS:

  950.         {

  951.             H265RawVPS *vps;

  952. 

  953.             err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*vps),

  954.                                             &cbs_h265_free_vps);

  955.             if (err < 0)

  956.                 return err;

  957.             vps = unit->content;

  958. 

  959.             err = cbs_h265_read_vps(ctx, &gbc, vps);

  960.             if (err < 0)

  961.                 return err;

  962. 

  963.             err = cbs_h265_replace_vps(ctx, unit);

  964.             if (err < 0)

  965.                 return err;

  966.         }

  967.         break;

  968.     case HEVC_NAL_SPS:

  969.         {

  970.             H265RawSPS *sps;

  971. 

  972.             err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*sps),

  973.                                             &cbs_h265_free_sps);

  974.             if (err < 0)

  975.                 return err;

  976.             sps = unit->content;

  977. 

  978.             err = cbs_h265_read_sps(ctx, &gbc, sps);

  979.             if (err < 0)

  980.                 return err;

  981. 

  982.             err = cbs_h265_replace_sps(ctx, unit);

  983.             if (err < 0)

  984.                 return err;

  985.         }

  986.         break;

  987. 

  988.     case HEVC_NAL_PPS:

  989.         {

  990.             H265RawPPS *pps;

  991. 

  992.             err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*pps),

  993.                                             &cbs_h265_free_pps);

  994.             if (err < 0)

  995.                 return err;

  996.             pps = unit->content;

  997. 

  998.             err = cbs_h265_read_pps(ctx, &gbc, pps);

  999.             if (err < 0)

  1000.                 return err;

  1001. 

  1002.             err = cbs_h265_replace_pps(ctx, unit);

  1003.             if (err < 0)

  1004.                 return err;

  1005.         }

  1006.         break;

  1007. 

  1008.     case HEVC_NAL_TRAIL_N:

  1009.     case HEVC_NAL_TRAIL_R:

  1010.     case HEVC_NAL_TSA_N:

  1011.     case HEVC_NAL_TSA_R:

  1012.     case HEVC_NAL_STSA_N:

  1013.     case HEVC_NAL_STSA_R:

  1014.     case HEVC_NAL_RADL_N:

  1015.     case HEVC_NAL_RADL_R:

  1016.     case HEVC_NAL_RASL_N:

  1017.     case HEVC_NAL_RASL_R:

  1018.     case HEVC_NAL_BLA_W_LP:

  1019.     case HEVC_NAL_BLA_W_RADL:

  1020.     case HEVC_NAL_BLA_N_LP:

  1021.     case HEVC_NAL_IDR_W_RADL:

  1022.     case HEVC_NAL_IDR_N_LP:

  1023.     case HEVC_NAL_CRA_NUT:

  1024.         {

  1025.             H265RawSlice *slice;

  1026.             int pos, len;

  1027. 

  1028.             err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*slice),

  1029.                                             &cbs_h265_free_slice);

  1030.             if (err < 0)

  1031.                 return err;

  1032.             slice = unit->content;

  1033. 

  1034.             err = cbs_h265_read_slice_segment_header(ctx, &gbc, &slice->header);

  1035.             if (err < 0)

  1036.                 return err;

  1037. 

  1038.             pos = get_bits_count(&gbc);

  1039.             len = unit->data_size;

  1040.             if (!unit->data[len - 1]) {

  1041.                 int z;

  1042.                 for (z = 0; z < len && !unit->data[len - z - 1]; z++);

  1043.                 av_log(ctx->log_ctx, AV_LOG_DEBUG, "Deleted %d trailing zeroes "

  1044.                        "from slice data.\n", z);

  1045.                 len -= z;

  1046.             }

  1047. 

  1048.             slice->data_size = len - pos / 8;

  1049.             slice->data_ref  = av_buffer_ref(unit->data_ref);

  1050.             if (!slice->data_ref)

  1051.                 return AVERROR(ENOMEM);

  1052.             slice->data = unit->data + pos / 8;

  1053.             slice->data_bit_start = pos % 8;

  1054.         }

  1055.         break;

  1056. 

  1057.     case HEVC_NAL_AUD:

  1058.         {

  1059.             err = ff_cbs_alloc_unit_content(ctx, unit,

  1060.                                             sizeof(H265RawAUD), NULL);

  1061.             if (err < 0)

  1062.                 return err;

  1063. 

  1064.             err = cbs_h265_read_aud(ctx, &gbc, unit->content);

  1065.             if (err < 0)

  1066.                 return err;

  1067.         }

  1068.         break;

  1069. 

  1070.     case HEVC_NAL_SEI_PREFIX:

  1071.     case HEVC_NAL_SEI_SUFFIX:

  1072.         {

  1073.             err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(H265RawSEI),

  1074.                                             &cbs_h265_free_sei);

  1075. 

  1076.             if (err < 0)

  1077.                 return err;

  1078. 

  1079.             err = cbs_h265_read_sei(ctx, &gbc, unit->content,

  1080.                                     unit->type == HEVC_NAL_SEI_PREFIX);

  1081. 

  1082.             if (err < 0)

  1083.                 return err;

  1084.         }

  1085.         break;

  1086. 

  1087.     default:

  1088.         return AVERROR(ENOSYS);

  1089.     }

  1090. 

  1091.     return 0;

  1092. }

  1093. 

  1094. static int cbs_h2645_write_slice_data(CodedBitstreamContext *ctx,

  1095.                                       PutBitContext *pbc, const uint8_t *data,

  1096.                                       size_t data_size, int data_bit_start)

  1097. {

  1098.     size_t rest  = data_size - (data_bit_start + 7) / 8;

  1099.     const uint8_t *pos = data + data_bit_start / 8;

  1100. 

  1101.     av_assert0(data_bit_start >= 0 &&

  1102.                8 * data_size > data_bit_start);

  1103. 

  1104.     if (data_size * 8 + 8 > put_bits_left(pbc))

  1105.         return AVERROR(ENOSPC);

  1106. 

  1107.     if (!rest)

  1108.         goto rbsp_stop_one_bit;

  1109. 

  1110.     // First copy the remaining bits of the first byte

  1111.     // The above check ensures that we do not accidentally

  1112.     // copy beyond the rbsp_stop_one_bit.

  1113.     if (data_bit_start % 8)

  1114.         put_bits(pbc, 8 - data_bit_start % 8,

  1115.                  *pos++ & MAX_UINT_BITS(8 - data_bit_start % 8));

  1116. 

  1117.     if (put_bits_count(pbc) % 8 == 0) {

  1118.         // If the writer is aligned at this point,

  1119.         // memcpy can be used to improve performance.

  1120.         // This happens normally for CABAC.

  1121.         flush_put_bits(pbc);

  1122.         memcpy(put_bits_ptr(pbc), pos, rest);

  1123.         skip_put_bytes(pbc, rest);

  1124.     } else {

  1125.         // If not, we have to copy manually.

  1126.         // rbsp_stop_one_bit forces us to special-case

  1127.         // the last byte.

  1128.         uint8_t temp;

  1129.         int i;

  1130. 

  1131.         for (; rest > 4; rest -= 4, pos += 4)

  1132.             put_bits32(pbc, AV_RB32(pos));

  1133. 

  1134.         for (; rest > 1; rest--, pos++)

  1135.             put_bits(pbc, 8, *pos);

  1136. 

  1137.     rbsp_stop_one_bit:

  1138.         temp = rest ? *pos : *pos & MAX_UINT_BITS(8 - data_bit_start % 8);

  1139. 

  1140.         av_assert0(temp);

  1141.         i = ff_ctz(*pos);

  1142.         temp = temp >> i;

  1143.         i = rest ? (8 - i) : (8 - i - data_bit_start % 8);

  1144.         put_bits(pbc, i, temp);

  1145.         if (put_bits_count(pbc) % 8)

  1146.             put_bits(pbc, 8 - put_bits_count(pbc) % 8, 0);

  1147.     }

  1148. 

  1149.     return 0;

  1150. }

  1151. 

  1152. static int cbs_h264_write_nal_unit(CodedBitstreamContext *ctx,

  1153.                                    CodedBitstreamUnit *unit,

  1154.                                    PutBitContext *pbc)

  1155. {

  1156.     int err;

  1157. 

  1158.     switch (unit->type) {

  1159.     case H264_NAL_SPS:

  1160.         {

  1161.             H264RawSPS *sps = unit->content;

  1162. 

  1163.             err = cbs_h264_write_sps(ctx, pbc, sps);

  1164.             if (err < 0)

  1165.                 return err;

  1166. 

  1167.             err = cbs_h264_replace_sps(ctx, unit);

  1168.             if (err < 0)

  1169.                 return err;

  1170.         }

  1171.         break;

  1172. 

  1173.     case H264_NAL_SPS_EXT:

  1174.         {

  1175.             H264RawSPSExtension *sps_ext = unit->content;

  1176. 

  1177.             err = cbs_h264_write_sps_extension(ctx, pbc, sps_ext);

  1178.             if (err < 0)

  1179.                 return err;

  1180.         }

  1181.         break;

  1182. 

  1183.     case H264_NAL_PPS:

  1184.         {

  1185.             H264RawPPS *pps = unit->content;

  1186. 

  1187.             err = cbs_h264_write_pps(ctx, pbc, pps);

  1188.             if (err < 0)

  1189.                 return err;

  1190. 

  1191.             err = cbs_h264_replace_pps(ctx, unit);

  1192.             if (err < 0)

  1193.                 return err;

  1194.         }

  1195.         break;

  1196. 

  1197.     case H264_NAL_SLICE:

  1198.     case H264_NAL_IDR_SLICE:

  1199.     case H264_NAL_AUXILIARY_SLICE:

  1200.         {

  1201.             H264RawSlice *slice = unit->content;

  1202. 

  1203.             err = cbs_h264_write_slice_header(ctx, pbc, &slice->header);

  1204.             if (err < 0)

  1205.                 return err;

  1206. 

  1207.             if (slice->data) {

  1208.                 err = cbs_h2645_write_slice_data(ctx, pbc, slice->data,

  1209.                                                  slice->data_size,

  1210.                                                  slice->data_bit_start);

  1211.                 if (err < 0)

  1212.                     return err;

  1213.             } else {

  1214.                 // No slice data - that was just the header.

  1215.                 // (Bitstream may be unaligned!)

  1216.             }

  1217.         }

  1218.         break;

  1219. 

  1220.     case H264_NAL_AUD:

  1221.         {

  1222.             err = cbs_h264_write_aud(ctx, pbc, unit->content);

  1223.             if (err < 0)

  1224.                 return err;

  1225.         }

  1226.         break;

  1227. 

  1228.     case H264_NAL_SEI:

  1229.         {

  1230.             err = cbs_h264_write_sei(ctx, pbc, unit->content);

  1231.             if (err < 0)

  1232.                 return err;

  1233.         }

  1234.         break;

  1235. 

  1236.     case H264_NAL_FILLER_DATA:

  1237.         {

  1238.             err = cbs_h264_write_filler(ctx, pbc, unit->content);

  1239.             if (err < 0)

  1240.                 return err;

  1241.         }

  1242.         break;

  1243. 

  1244.     case H264_NAL_END_SEQUENCE:

  1245.         {

  1246.             err = cbs_h264_write_end_of_sequence(ctx, pbc, unit->content);

  1247.             if (err < 0)

  1248.                 return err;

  1249.         }

  1250.         break;

  1251. 

  1252.     case H264_NAL_END_STREAM:

  1253.         {

  1254.             err = cbs_h264_write_end_of_stream(ctx, pbc, unit->content);

  1255.             if (err < 0)

  1256.                 return err;

  1257.         }

  1258.         break;

  1259. 

  1260.     default:

  1261.         av_log(ctx->log_ctx, AV_LOG_ERROR, "Write unimplemented for "

  1262.                "NAL unit type %"PRIu32".\n", unit->type);

  1263.         return AVERROR_PATCHWELCOME;

  1264.     }

  1265. 

  1266.     return 0;

  1267. }

  1268. 

  1269. static int cbs_h265_write_nal_unit(CodedBitstreamContext *ctx,

  1270.                                    CodedBitstreamUnit *unit,

  1271.                                    PutBitContext *pbc)

  1272. {

  1273.     int err;

  1274. 

  1275.     switch (unit->type) {

  1276.     case HEVC_NAL_VPS:

  1277.         {

  1278.             H265RawVPS *vps = unit->content;

  1279. 

  1280.             err = cbs_h265_write_vps(ctx, pbc, vps);

  1281.             if (err < 0)

  1282.                 return err;

  1283. 

  1284.             err = cbs_h265_replace_vps(ctx, unit);

  1285.             if (err < 0)

  1286.                 return err;

  1287.         }

  1288.         break;

  1289. 

  1290.     case HEVC_NAL_SPS:

  1291.         {

  1292.             H265RawSPS *sps = unit->content;

  1293. 

  1294.             err = cbs_h265_write_sps(ctx, pbc, sps);

  1295.             if (err < 0)

  1296.                 return err;

  1297. 

  1298.             err = cbs_h265_replace_sps(ctx, unit);

  1299.             if (err < 0)

  1300.                 return err;

  1301.         }

  1302.         break;

  1303. 

  1304.     case HEVC_NAL_PPS:

  1305.         {

  1306.             H265RawPPS *pps = unit->content;

  1307. 

  1308.             err = cbs_h265_write_pps(ctx, pbc, pps);

  1309.             if (err < 0)

  1310.                 return err;

  1311. 

  1312.             err = cbs_h265_replace_pps(ctx, unit);

  1313.             if (err < 0)

  1314.                 return err;

  1315.         }

  1316.         break;

  1317. 

  1318.     case HEVC_NAL_TRAIL_N:

  1319.     case HEVC_NAL_TRAIL_R:

  1320.     case HEVC_NAL_TSA_N:

  1321.     case HEVC_NAL_TSA_R:

  1322.     case HEVC_NAL_STSA_N:

  1323.     case HEVC_NAL_STSA_R:

  1324.     case HEVC_NAL_RADL_N:

  1325.     case HEVC_NAL_RADL_R:

  1326.     case HEVC_NAL_RASL_N:

  1327.     case HEVC_NAL_RASL_R:

  1328.     case HEVC_NAL_BLA_W_LP:

  1329.     case HEVC_NAL_BLA_W_RADL:

  1330.     case HEVC_NAL_BLA_N_LP:

  1331.     case HEVC_NAL_IDR_W_RADL:

  1332.     case HEVC_NAL_IDR_N_LP:

  1333.     case HEVC_NAL_CRA_NUT:

  1334.         {

  1335.             H265RawSlice *slice = unit->content;

  1336. 

  1337.             err = cbs_h265_write_slice_segment_header(ctx, pbc, &slice->header);

  1338.             if (err < 0)

  1339.                 return err;

  1340. 

  1341.             if (slice->data) {

  1342.                 err = cbs_h2645_write_slice_data(ctx, pbc, slice->data,

  1343.                                                  slice->data_size,

  1344.                                                  slice->data_bit_start);

  1345.                 if (err < 0)

  1346.                     return err;

  1347.             } else {

  1348.                 // No slice data - that was just the header.

  1349.             }

  1350.         }

  1351.         break;

  1352. 

  1353.     case HEVC_NAL_AUD:

  1354.         {

  1355.             err = cbs_h265_write_aud(ctx, pbc, unit->content);

  1356.             if (err < 0)

  1357.                 return err;

  1358.         }

  1359.         break;

  1360. 

  1361.     case HEVC_NAL_SEI_PREFIX:

  1362.     case HEVC_NAL_SEI_SUFFIX:

  1363.         {

  1364.             err = cbs_h265_write_sei(ctx, pbc, unit->content,

  1365.                                      unit->type == HEVC_NAL_SEI_PREFIX);

  1366. 

  1367.             if (err < 0)

  1368.                 return err;

  1369.         }

  1370.         break;

  1371. 

  1372.     default:

  1373.         av_log(ctx->log_ctx, AV_LOG_ERROR, "Write unimplemented for "

  1374.                "NAL unit type %"PRIu32".\n", unit->type);

  1375.         return AVERROR_PATCHWELCOME;

  1376.     }

  1377. 

  1378.     return 0;

  1379. }

  1380. 

  1381. static int cbs_h2645_write_nal_unit(CodedBitstreamContext *ctx,

  1382.                                     CodedBitstreamUnit *unit)

  1383. {

  1384.     CodedBitstreamH2645Context *priv = ctx->priv_data;

  1385.     enum AVCodecID codec_id = ctx->codec->codec_id;

  1386.     PutBitContext pbc;

  1387.     int err;

  1388. 

  1389.     if (!priv->write_buffer) {

  1390.         // Initial write buffer size is 1MB.

  1391.         priv->write_buffer_size = 1024 * 1024;

  1392. 

  1393.     reallocate_and_try_again:

  1394.         err = av_reallocp(&priv->write_buffer, priv->write_buffer_size);

  1395.         if (err < 0) {

  1396.             av_log(ctx->log_ctx, AV_LOG_ERROR, "Unable to allocate a "

  1397.                    "sufficiently large write buffer (last attempt "

  1398.                    "%"SIZE_SPECIFIER" bytes).\n", priv->write_buffer_size);

  1399.             return err;

  1400.         }

  1401.     }

  1402. 

  1403.     init_put_bits(&pbc, priv->write_buffer, priv->write_buffer_size);

  1404. 

  1405.     if (codec_id == AV_CODEC_ID_H264)

  1406.         err = cbs_h264_write_nal_unit(ctx, unit, &pbc);

  1407.     else

  1408.         err = cbs_h265_write_nal_unit(ctx, unit, &pbc);

  1409. 

  1410.     if (err == AVERROR(ENOSPC)) {

  1411.         // Overflow.

  1412.         priv->write_buffer_size *= 2;

  1413.         goto reallocate_and_try_again;

  1414.     }

  1415.     // Overflow but we didn't notice.

  1416.     av_assert0(put_bits_count(&pbc) <= 8 * priv->write_buffer_size);

  1417. 

  1418.     if (err < 0) {

  1419.         // Write failed for some other reason.

  1420.         return err;

  1421.     }

  1422. 

  1423.     if (put_bits_count(&pbc) % 8)

  1424.         unit->data_bit_padding = 8 - put_bits_count(&pbc) % 8;

  1425.     else

  1426.         unit->data_bit_padding = 0;

  1427. 

  1428.     unit->data_size = (put_bits_count(&pbc) + 7) / 8;

  1429.     flush_put_bits(&pbc);

  1430. 

  1431.     err = ff_cbs_alloc_unit_data(ctx, unit, unit->data_size);

  1432.     if (err < 0)

  1433.         return err;

  1434. 

  1435.     memcpy(unit->data, priv->write_buffer, unit->data_size);

  1436. 

  1437.     return 0;

  1438. }

  1439. 

  1440. static int cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx,

  1441.                                        CodedBitstreamFragment *frag)

  1442. {

  1443.     uint8_t *data;

  1444.     size_t max_size, dp, sp;

  1445.     int err, i, zero_run;

  1446. 

  1447.     for (i = 0; i < frag->nb_units; i++) {

  1448.         // Data should already all have been written when we get here.

  1449.         av_assert0(frag->units[i].data);

  1450.     }

  1451. 

  1452.     max_size = 0;

  1453.     for (i = 0; i < frag->nb_units; i++) {

  1454.         // Start code + content with worst-case emulation prevention.

  1455.         max_size += 3 + frag->units[i].data_size * 3 / 2;

  1456.     }

  1457. 

  1458.     data = av_malloc(max_size + AV_INPUT_BUFFER_PADDING_SIZE);

  1459.     if (!data)

  1460.         return AVERROR(ENOMEM);

  1461. 

  1462.     dp = 0;

  1463.     for (i = 0; i < frag->nb_units; i++) {

  1464.         CodedBitstreamUnit *unit = &frag->units[i];

  1465. 

  1466.         if (unit->data_bit_padding > 0) {

  1467.             if (i < frag->nb_units - 1)

  1468.                 av_log(ctx->log_ctx, AV_LOG_WARNING, "Probably invalid "

  1469.                        "unaligned padding on non-final NAL unit.\n");

  1470.             else

  1471.                 frag->data_bit_padding = unit->data_bit_padding;

  1472.         }

  1473. 

  1474.         if ((ctx->codec->codec_id == AV_CODEC_ID_H264 &&

  1475.              (unit->type == H264_NAL_SPS ||

  1476.               unit->type == H264_NAL_PPS)) ||

  1477.             (ctx->codec->codec_id == AV_CODEC_ID_HEVC &&

  1478.              (unit->type == HEVC_NAL_VPS ||

  1479.               unit->type == HEVC_NAL_SPS ||

  1480.               unit->type == HEVC_NAL_PPS)) ||

  1481.             i == 0 /* (Assume this is the start of an access unit.) */) {

  1482.             // zero_byte

  1483.             data[dp++] = 0;

  1484.         }

  1485.         // start_code_prefix_one_3bytes

  1486.         data[dp++] = 0;

  1487.         data[dp++] = 0;

  1488.         data[dp++] = 1;

  1489. 

  1490.         zero_run = 0;

  1491.         for (sp = 0; sp < unit->data_size; sp++) {

  1492.             if (zero_run < 2) {

  1493.                 if (unit->data[sp] == 0)

  1494.                     ++zero_run;

  1495.                 else

  1496.                     zero_run = 0;

  1497.             } else {

  1498.                 if ((unit->data[sp] & ~3) == 0) {

  1499.                     // emulation_prevention_three_byte

  1500.                     data[dp++] = 3;

  1501.                 }

  1502.                 zero_run = unit->data[sp] == 0;

  1503.             }

  1504.             data[dp++] = unit->data[sp];

  1505.         }

  1506.     }

  1507. 

  1508.     av_assert0(dp <= max_size);

  1509.     err = av_reallocp(&data, dp + AV_INPUT_BUFFER_PADDING_SIZE);

  1510.     if (err)

  1511.         return err;

  1512.     memset(data + dp, 0, AV_INPUT_BUFFER_PADDING_SIZE);

  1513. 

  1514.     frag->data_ref = av_buffer_create(data, dp + AV_INPUT_BUFFER_PADDING_SIZE,

  1515.                                       NULL, NULL, 0);

  1516.     if (!frag->data_ref) {

  1517.         av_freep(&data);

  1518.         return AVERROR(ENOMEM);

  1519.     }

  1520. 

  1521.     frag->data = data;

  1522.     frag->data_size = dp;

  1523. 

  1524.     return 0;

  1525. }

  1526. 

  1527. static void cbs_h264_close(CodedBitstreamContext *ctx)

  1528. {

  1529.     CodedBitstreamH264Context *h264 = ctx->priv_data;

  1530.     int i;

  1531. 

  1532.     ff_h2645_packet_uninit(&h264->common.read_packet);

  1533. 

  1534.     av_freep(&h264->common.write_buffer);

  1535. 

  1536.     for (i = 0; i < FF_ARRAY_ELEMS(h264->sps); i++)

  1537.         av_buffer_unref(&h264->sps_ref[i]);

  1538.     for (i = 0; i < FF_ARRAY_ELEMS(h264->pps); i++)

  1539.         av_buffer_unref(&h264->pps_ref[i]);

  1540. }

  1541. 

  1542. static void cbs_h265_close(CodedBitstreamContext *ctx)

  1543. {

  1544.     CodedBitstreamH265Context *h265 = ctx->priv_data;

  1545.     int i;

  1546. 

  1547.     ff_h2645_packet_uninit(&h265->common.read_packet);

  1548. 

  1549.     av_freep(&h265->common.write_buffer);

  1550. 

  1551.     for (i = 0; i < FF_ARRAY_ELEMS(h265->vps); i++)

  1552.         av_buffer_unref(&h265->vps_ref[i]);

  1553.     for (i = 0; i < FF_ARRAY_ELEMS(h265->sps); i++)

  1554.         av_buffer_unref(&h265->sps_ref[i]);

  1555.     for (i = 0; i < FF_ARRAY_ELEMS(h265->pps); i++)

  1556.         av_buffer_unref(&h265->pps_ref[i]);

  1557. }

  1558. 

  1559. const CodedBitstreamType ff_cbs_type_h264 = {

  1560.     .codec_id          = AV_CODEC_ID_H264,

  1561. 

  1562.     .priv_data_size    = sizeof(CodedBitstreamH264Context),

  1563. 

  1564.     .split_fragment    = &cbs_h2645_split_fragment,

  1565.     .read_unit         = &cbs_h264_read_nal_unit,

  1566.     .write_unit        = &cbs_h2645_write_nal_unit,

  1567.     .assemble_fragment = &cbs_h2645_assemble_fragment,

  1568. 

  1569.     .close             = &cbs_h264_close,

  1570. };

  1571. 

  1572. const CodedBitstreamType ff_cbs_type_h265 = {

  1573.     .codec_id          = AV_CODEC_ID_HEVC,

  1574. 

  1575.     .priv_data_size    = sizeof(CodedBitstreamH265Context),

  1576. 

  1577.     .split_fragment    = &cbs_h2645_split_fragment,

  1578.     .read_unit         = &cbs_h265_read_nal_unit,

  1579.     .write_unit        = &cbs_h2645_write_nal_unit,

  1580.     .assemble_fragment = &cbs_h2645_assemble_fragment,

  1581. 

  1582.     .close             = &cbs_h265_close,

  1583. };

  1584. 

  1585. int ff_cbs_h264_add_sei_message(CodedBitstreamContext *ctx,

  1586.                                 CodedBitstreamFragment *au,

  1587.                                 const H264RawSEIPayload *payload)

  1588. {

  1589.     H264RawSEI *sei;

  1590.     CodedBitstreamUnit *nal = NULL;

  1591.     int err, i;

  1592. 

  1593.     // Find an existing SEI NAL unit to add to.

  1594.     for (i = 0; i < au->nb_units; i++) {

  1595.         if (au->units[i].type == H264_NAL_SEI) {

  1596.             nal = &au->units[i];

  1597.             break;

  1598.         }

  1599.     }

  1600.     if (nal) {

  1601.         sei = nal->content;

  1602. 

  1603.     } else {

  1604.         // Need to make a new SEI NAL unit.  Insert it before the first

  1605.         // slice data NAL unit; if no slice data, add at the end.

  1606.         AVBufferRef *sei_ref;

  1607. 

  1608.         sei = av_mallocz(sizeof(*sei));

  1609.         if (!sei)

  1610.             return AVERROR(ENOMEM);

  1611. 

  1612.         sei->nal_unit_header.nal_unit_type = H264_NAL_SEI;

  1613.         sei->nal_unit_header.nal_ref_idc   = 0;

  1614. 

  1615.         sei_ref = av_buffer_create((uint8_t*)sei, sizeof(*sei),

  1616.                                    &cbs_h264_free_sei, ctx, 0);

  1617.         if (!sei_ref) {

  1618.             av_freep(&sei);

  1619.             return AVERROR(ENOMEM);

  1620.         }

  1621. 

  1622.         for (i = 0; i < au->nb_units; i++) {

  1623.             if (au->units[i].type == H264_NAL_SLICE ||

  1624.                 au->units[i].type == H264_NAL_IDR_SLICE)

  1625.                 break;

  1626.         }

  1627. 

  1628.         err = ff_cbs_insert_unit_content(ctx, au, i, H264_NAL_SEI,

  1629.                                          sei, sei_ref);

  1630.         av_buffer_unref(&sei_ref);

  1631.         if (err < 0)

  1632.             return err;

  1633.     }

  1634. 

  1635.     if (sei->payload_count >= H264_MAX_SEI_PAYLOADS) {

  1636.         av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many payloads in "

  1637.                "SEI NAL unit.\n");

  1638.         return AVERROR(EINVAL);

  1639.     }

  1640. 

  1641.     memcpy(&sei->payload[sei->payload_count], payload, sizeof(*payload));

  1642.     ++sei->payload_count;

  1643. 

  1644.     return 0;

  1645. }

  1646. 

  1647. void ff_cbs_h264_delete_sei_message(CodedBitstreamContext *ctx,

  1648.                                     CodedBitstreamFragment *au,

  1649.                                     CodedBitstreamUnit *nal,

  1650.                                     int position)

  1651. {

  1652.     H264RawSEI *sei = nal->content;

  1653. 

  1654.     av_assert0(nal->type == H264_NAL_SEI);

  1655.     av_assert0(position >= 0 && position < sei->payload_count);

  1656. 

  1657.     if (position == 0 && sei->payload_count == 1) {

  1658.         // Deleting NAL unit entirely.

  1659.         int i;

  1660. 

  1661.         for (i = 0; i < au->nb_units; i++) {

  1662.             if (&au->units[i] == nal)

  1663.                 break;

  1664.         }

  1665. 

  1666.         ff_cbs_delete_unit(ctx, au, i);

  1667.     } else {

  1668.         cbs_h264_free_sei_payload(&sei->payload[position]);

  1669. 

  1670.         --sei->payload_count;

  1671.         memmove(sei->payload + position,

  1672.                 sei->payload + position + 1,

  1673.                 (sei->payload_count - position) * sizeof(*sei->payload));

  1674.     }

  1675. }