bare-ffmpeg 1.0.0-2 → 1.0.0-21

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (47) hide show
  1. package/CMakeLists.txt +10 -3
  2. package/README.md +1097 -0
  3. package/binding.cc +3330 -0
  4. package/cmake/ports/ffmpeg/port.cmake +513 -0
  5. package/cmake/ports/opus/patches/01-windows-clang.patch +52 -0
  6. package/cmake/ports/opus/port.cmake +42 -0
  7. package/cmake/ports/svt-av1/port.cmake +42 -0
  8. package/cmake/ports/x264/patches/01-windows-clang.patch +33 -0
  9. package/cmake/ports/x264/port.cmake +157 -0
  10. package/index.js +14 -4
  11. package/lib/audio-fifo.js +47 -0
  12. package/lib/channel-layout.js +35 -0
  13. package/lib/codec-context.js +92 -15
  14. package/lib/codec-parameters.js +230 -8
  15. package/lib/codec.js +19 -0
  16. package/lib/constants.js +163 -8
  17. package/lib/dictionary.js +18 -15
  18. package/lib/errors.js +38 -0
  19. package/lib/format-context.js +62 -31
  20. package/lib/frame.js +87 -16
  21. package/lib/image.js +22 -0
  22. package/lib/input-format.js +8 -3
  23. package/lib/io-context.js +29 -6
  24. package/lib/log.js +16 -0
  25. package/lib/output-format.js +4 -0
  26. package/lib/packet.js +88 -13
  27. package/lib/rational.js +35 -1
  28. package/lib/resampler.js +63 -0
  29. package/lib/samples.js +49 -0
  30. package/lib/scaler.js +8 -7
  31. package/lib/stream.js +37 -12
  32. package/package.json +7 -4
  33. package/prebuilds/android-arm/bare-ffmpeg.bare +0 -0
  34. package/prebuilds/android-arm64/bare-ffmpeg.bare +0 -0
  35. package/prebuilds/android-ia32/bare-ffmpeg.bare +0 -0
  36. package/prebuilds/android-x64/bare-ffmpeg.bare +0 -0
  37. package/prebuilds/darwin-arm64/bare-ffmpeg.bare +0 -0
  38. package/prebuilds/darwin-x64/bare-ffmpeg.bare +0 -0
  39. package/prebuilds/ios-arm64/bare-ffmpeg.bare +0 -0
  40. package/prebuilds/ios-arm64-simulator/bare-ffmpeg.bare +0 -0
  41. package/prebuilds/ios-x64-simulator/bare-ffmpeg.bare +0 -0
  42. package/prebuilds/linux-arm64/bare-ffmpeg.bare +0 -0
  43. package/prebuilds/linux-x64/bare-ffmpeg.bare +0 -0
  44. package/prebuilds/win32-arm64/bare-ffmpeg.bare +0 -0
  45. package/prebuilds/win32-x64/bare-ffmpeg.bare +0 -0
  46. package/binding.c +0 -2128
  47. package/lib/reference-counted.js +0 -39
package/binding.c DELETED
@@ -1,2128 +0,0 @@
1
- #include <assert.h>
2
- #include <bare.h>
3
- #include <js.h>
4
- #include <libavcodec/avcodec.h>
5
- #include <libavcodec/codec.h>
6
- #include <libavcodec/codec_id.h>
7
- #include <libavcodec/codec_par.h>
8
- #include <libavcodec/packet.h>
9
- #include <libavdevice/avdevice.h>
10
- #include <libavformat/avformat.h>
11
- #include <libavformat/avio.h>
12
- #include <libavutil/dict.h>
13
- #include <libavutil/error.h>
14
- #include <libavutil/frame.h>
15
- #include <libavutil/imgutils.h>
16
- #include <libavutil/log.h>
17
- #include <libavutil/mem.h>
18
- #include <libavutil/pixfmt.h>
19
- #include <libavutil/rational.h>
20
- #include <libswscale/swscale.h>
21
- #include <stddef.h>
22
- #include <stdint.h>
23
- #include <string.h>
24
-
25
- typedef struct {
26
- AVIOContext *handle;
27
- } bare_ffmpeg_io_context_t;
28
-
29
- typedef struct {
30
- const AVOutputFormat *handle;
31
- } bare_ffmpeg_output_format_t;
32
-
33
- typedef struct {
34
- const AVInputFormat *handle;
35
- } bare_ffmpeg_input_format_t;
36
-
37
- typedef struct {
38
- AVFormatContext *handle;
39
- } bare_ffmpeg_format_context_t;
40
-
41
- typedef struct {
42
- AVStream *handle;
43
- } bare_ffmpeg_stream_t;
44
-
45
- typedef struct {
46
- const AVCodec *handle;
47
- } bare_ffmpeg_codec_t;
48
-
49
- typedef struct {
50
- AVCodecParameters *handle;
51
- } bare_ffmpeg_codec_parameters_t;
52
-
53
- typedef struct {
54
- AVCodecContext *handle;
55
- } bare_ffmpeg_codec_context_t;
56
-
57
- typedef struct {
58
- AVFrame *handle;
59
- } bare_ffmpeg_frame_t;
60
-
61
- typedef struct {
62
- AVPacket *handle;
63
- } bare_ffmpeg_packet_t;
64
-
65
- typedef struct {
66
- struct SwsContext *handle;
67
- } bare_ffmpeg_scaler_t;
68
-
69
- typedef struct {
70
- struct AVDictionary *handle;
71
- } bare_ffmpeg_dictionary_t;
72
-
73
- static uv_once_t bare_ffmpeg__init_guard = UV_ONCE_INIT;
74
-
75
- static void
76
- bare_ffmpeg__on_init(void) {
77
- av_log_set_level(AV_LOG_ERROR);
78
- avdevice_register_all();
79
- }
80
-
81
- static js_value_t *
82
- bare_ffmpeg_io_context_init(js_env_t *env, js_callback_info_t *info) {
83
- int err;
84
-
85
- size_t argc = 1;
86
- js_value_t *argv[1];
87
-
88
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
89
- assert(err == 0);
90
-
91
- assert(argc == 1);
92
-
93
- void *data;
94
- size_t len;
95
- err = js_get_typedarray_info(env, argv[0], NULL, &data, &len, NULL, NULL);
96
- assert(err == 0);
97
-
98
- js_value_t *handle;
99
-
100
- bare_ffmpeg_io_context_t *context;
101
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_io_context_t), (void **) &context, &handle);
102
- assert(err == 0);
103
-
104
- uint8_t *io;
105
-
106
- if (len == 0) io = NULL;
107
- else {
108
- io = av_malloc(len);
109
-
110
- memcpy(io, data, len);
111
- }
112
-
113
- context->handle = avio_alloc_context(io, len, 0, NULL, NULL, NULL, NULL);
114
-
115
- context->handle->opaque = (void *) context;
116
-
117
- return handle;
118
- }
119
-
120
- static js_value_t *
121
- bare_ffmpeg_io_context_destroy(js_env_t *env, js_callback_info_t *info) {
122
- int err;
123
-
124
- size_t argc = 1;
125
- js_value_t *argv[1];
126
-
127
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
128
- assert(err == 0);
129
-
130
- assert(argc == 1);
131
-
132
- bare_ffmpeg_io_context_t *context;
133
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
134
- assert(err == 0);
135
-
136
- av_free(context->handle->buffer);
137
-
138
- avio_context_free(&context->handle);
139
-
140
- return NULL;
141
- }
142
-
143
- static js_value_t *
144
- bare_ffmpeg_output_format_init(js_env_t *env, js_callback_info_t *info) {
145
- int err;
146
-
147
- size_t argc = 1;
148
- js_value_t *argv[1];
149
-
150
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
151
- assert(err == 0);
152
-
153
- assert(argc == 1);
154
-
155
- size_t len;
156
- err = js_get_value_string_utf8(env, argv[0], NULL, 0, &len);
157
- assert(err == 0);
158
-
159
- len += +1 /* NULL */;
160
-
161
- utf8_t *name = malloc(len);
162
- err = js_get_value_string_utf8(env, argv[0], name, len, NULL);
163
- assert(err == 0);
164
-
165
- const AVOutputFormat *format = av_guess_format((const char *) name, NULL, NULL);
166
-
167
- if (format == NULL) {
168
- err = js_throw_errorf(env, NULL, "No output format found for name '%s'", name);
169
- assert(err == 0);
170
- free(name);
171
-
172
- return NULL;
173
- }
174
- free(name);
175
-
176
- js_value_t *handle;
177
-
178
- bare_ffmpeg_output_format_t *context;
179
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_output_format_t), (void **) &context, &handle);
180
- assert(err == 0);
181
-
182
- context->handle = format;
183
-
184
- return handle;
185
- }
186
-
187
- static js_value_t *
188
- bare_ffmpeg_input_format_init(js_env_t *env, js_callback_info_t *info) {
189
- int err;
190
-
191
- size_t argc = 1;
192
- js_value_t *argv[1];
193
-
194
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
195
- assert(err == 0);
196
-
197
- assert(argc == 1);
198
-
199
- size_t len;
200
- err = js_get_value_string_utf8(env, argv[0], NULL, 0, &len);
201
- assert(err == 0);
202
-
203
- len += +1 /* NULL */;
204
-
205
- utf8_t *name = malloc(len);
206
- err = js_get_value_string_utf8(env, argv[0], name, len, NULL);
207
- assert(err == 0);
208
-
209
- const AVInputFormat *format = av_find_input_format((const char *) name);
210
-
211
- if (format == NULL) {
212
- err = js_throw_errorf(env, NULL, "No input format found for name '%s'", name);
213
- assert(err == 0);
214
- free(name);
215
-
216
- return NULL;
217
- }
218
- free(name);
219
-
220
- js_value_t *handle;
221
-
222
- bare_ffmpeg_input_format_t *context;
223
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_input_format_t), (void **) &context, &handle);
224
- assert(err == 0);
225
-
226
- context->handle = format;
227
-
228
- return handle;
229
- }
230
-
231
- static js_value_t *
232
- bare_ffmpeg_format_context_open_input_with_io(js_env_t *env, js_callback_info_t *info) {
233
- int err;
234
-
235
- size_t argc = 1;
236
- js_value_t *argv[1];
237
-
238
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
239
- assert(err == 0);
240
-
241
- assert(argc == 1);
242
-
243
- bare_ffmpeg_io_context_t *io;
244
- err = js_get_arraybuffer_info(env, argv[0], (void **) &io, NULL);
245
- assert(err == 0);
246
-
247
- js_value_t *handle;
248
-
249
- bare_ffmpeg_format_context_t *context;
250
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_format_context_t), (void **) &context, &handle);
251
- assert(err == 0);
252
-
253
- context->handle = avformat_alloc_context();
254
-
255
- context->handle->pb = io->handle;
256
- context->handle->opaque = (void *) context;
257
-
258
- err = avformat_open_input(&context->handle, NULL, NULL, NULL);
259
-
260
- if (err < 0) {
261
- avformat_free_context(context->handle);
262
-
263
- err = js_throw_error(env, NULL, av_err2str(err));
264
- assert(err == 0);
265
-
266
- return NULL;
267
- }
268
-
269
- err = avformat_find_stream_info(context->handle, NULL);
270
-
271
- if (err < 0) {
272
- avformat_close_input(&context->handle);
273
-
274
- err = js_throw_error(env, NULL, av_err2str(err));
275
- assert(err == 0);
276
-
277
- return NULL;
278
- }
279
-
280
- return handle;
281
- }
282
-
283
- static js_value_t *
284
- bare_ffmpeg_format_context_open_input_with_format(js_env_t *env, js_callback_info_t *info) {
285
- int err;
286
-
287
- size_t argc = 3;
288
- js_value_t *argv[3];
289
-
290
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
291
- assert(err == 0);
292
- assert(argc == 3);
293
-
294
- bare_ffmpeg_input_format_t *format;
295
- err = js_get_arraybuffer_info(env, argv[0], (void **) &format, NULL);
296
- assert(err == 0);
297
-
298
- js_value_t *handle;
299
-
300
- bare_ffmpeg_format_context_t *context;
301
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_format_context_t), (void **) &context, &handle);
302
- assert(err == 0);
303
-
304
- context->handle = avformat_alloc_context();
305
- context->handle->opaque = (void *) context;
306
-
307
- bare_ffmpeg_dictionary_t *options;
308
- err = js_get_arraybuffer_info(env, argv[1], (void **) &options, NULL);
309
- assert(err == 0);
310
-
311
- size_t len;
312
- err = js_get_value_string_utf8(env, argv[2], NULL, 0, &len);
313
- assert(err == 0);
314
-
315
- len += +1 /* NULL */;
316
-
317
- utf8_t *url = malloc(len);
318
- err = js_get_value_string_utf8(env, argv[2], url, len, NULL);
319
- assert(err == 0);
320
-
321
- err = avformat_open_input(&context->handle, (char *) url, format->handle, &options->handle);
322
- free(url);
323
-
324
- if (err < 0) {
325
- avformat_free_context(context->handle);
326
-
327
- err = js_throw_error(env, NULL, av_err2str(err));
328
- assert(err == 0);
329
-
330
- return NULL;
331
- }
332
-
333
- err = avformat_find_stream_info(context->handle, NULL);
334
-
335
- if (err < 0) {
336
- avformat_close_input(&context->handle);
337
-
338
- err = js_throw_error(env, NULL, av_err2str(err));
339
- assert(err == 0);
340
-
341
- return NULL;
342
- }
343
-
344
- return handle;
345
- }
346
-
347
- static js_value_t *
348
- bare_ffmpeg_format_context_close_input(js_env_t *env, js_callback_info_t *info) {
349
- int err;
350
-
351
- size_t argc = 1;
352
- js_value_t *argv[1];
353
-
354
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
355
- assert(err == 0);
356
-
357
- assert(argc == 1);
358
-
359
- bare_ffmpeg_format_context_t *context;
360
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
361
- assert(err == 0);
362
-
363
- avformat_close_input(&context->handle);
364
-
365
- return NULL;
366
- }
367
-
368
- static js_value_t *
369
- bare_ffmpeg_format_context_open_output(js_env_t *env, js_callback_info_t *info) {
370
- int err;
371
-
372
- size_t argc = 2;
373
- js_value_t *argv[2];
374
-
375
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
376
- assert(err == 0);
377
-
378
- assert(argc == 2);
379
-
380
- bare_ffmpeg_output_format_t *format;
381
- err = js_get_arraybuffer_info(env, argv[0], (void **) &format, NULL);
382
- assert(err == 0);
383
-
384
- bare_ffmpeg_io_context_t *io;
385
- err = js_get_arraybuffer_info(env, argv[1], (void **) &io, NULL);
386
- assert(err == 0);
387
-
388
- js_value_t *handle;
389
-
390
- bare_ffmpeg_format_context_t *context;
391
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_format_context_t), (void **) &context, &handle);
392
- assert(err == 0);
393
-
394
- err = avformat_alloc_output_context2(&context->handle, format->handle, NULL, NULL);
395
-
396
- if (err < 0) {
397
- err = js_throw_error(env, NULL, av_err2str(err));
398
- assert(err == 0);
399
-
400
- return NULL;
401
- }
402
-
403
- context->handle->pb = io->handle;
404
- context->handle->opaque = (void *) context;
405
-
406
- return handle;
407
- }
408
-
409
- static js_value_t *
410
- bare_ffmpeg_format_context_close_output(js_env_t *env, js_callback_info_t *info) {
411
- int err;
412
-
413
- size_t argc = 1;
414
- js_value_t *argv[1];
415
-
416
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
417
- assert(err == 0);
418
-
419
- assert(argc == 1);
420
-
421
- bare_ffmpeg_format_context_t *context;
422
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
423
- assert(err == 0);
424
-
425
- avformat_free_context(context->handle);
426
-
427
- return NULL;
428
- }
429
-
430
- static js_value_t *
431
- bare_ffmpeg_format_context_get_streams(js_env_t *env, js_callback_info_t *info) {
432
- int err;
433
-
434
- size_t argc = 1;
435
- js_value_t *argv[1];
436
-
437
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
438
- assert(err == 0);
439
-
440
- assert(argc == 1);
441
-
442
- bare_ffmpeg_format_context_t *context;
443
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
444
- assert(err == 0);
445
-
446
- uint32_t len = context->handle->nb_streams;
447
-
448
- js_value_t *result;
449
- err = js_create_array_with_length(env, len, &result);
450
- assert(err == 0);
451
-
452
- for (uint32_t i = 0; i < len; i++) {
453
- js_value_t *handle;
454
-
455
- bare_ffmpeg_stream_t *stream;
456
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_stream_t), (void **) &stream, &handle);
457
- assert(err == 0);
458
-
459
- stream->handle = context->handle->streams[i];
460
-
461
- err = js_set_element(env, result, i, handle);
462
- assert(err == 0);
463
- }
464
-
465
- return result;
466
- }
467
-
468
- static js_value_t *
469
- bare_ffmpeg_format_context_get_best_stream_index(js_env_t *env, js_callback_info_t *info) {
470
- int err;
471
-
472
- size_t argc = 2;
473
- js_value_t *argv[2];
474
-
475
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
476
- assert(err == 0);
477
-
478
- assert(argc == 2);
479
-
480
- bare_ffmpeg_format_context_t *context;
481
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
482
- assert(err == 0);
483
-
484
- int type;
485
- err = js_get_value_int32(env, argv[1], &type);
486
- assert(err == 0);
487
-
488
- int stream_index = av_find_best_stream(context->handle, type, -1, -1, NULL, 0);
489
- if (stream_index < 0) {
490
- stream_index = -1;
491
- }
492
-
493
- js_value_t *result;
494
- err = js_create_int32(env, stream_index, &result);
495
- assert(err == 0);
496
-
497
- return result;
498
- }
499
-
500
- static js_value_t *
501
- bare_ffmpeg_format_context_create_stream(js_env_t *env, js_callback_info_t *info) {
502
- int err;
503
-
504
- size_t argc = 2;
505
- js_value_t *argv[2];
506
-
507
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
508
- assert(err == 0);
509
-
510
- assert(argc == 2);
511
-
512
- bare_ffmpeg_format_context_t *context;
513
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
514
- assert(err == 0);
515
-
516
- bare_ffmpeg_codec_t *codec;
517
- err = js_get_arraybuffer_info(env, argv[1], (void **) &codec, NULL);
518
- assert(err == 0);
519
-
520
- js_value_t *handle;
521
-
522
- bare_ffmpeg_stream_t *stream;
523
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_stream_t), (void **) &stream, &handle);
524
- assert(err == 0);
525
-
526
- stream->handle = avformat_new_stream(context->handle, codec->handle);
527
-
528
- if (stream->handle == NULL) {
529
- err = js_throw_error(env, NULL, av_err2str(err));
530
- assert(err == 0);
531
-
532
- return NULL;
533
- }
534
-
535
- return handle;
536
- }
537
-
538
- static js_value_t *
539
- bare_ffmpeg_format_context_read_frame(js_env_t *env, js_callback_info_t *info) {
540
- int err;
541
-
542
- size_t argc = 2;
543
- js_value_t *argv[2];
544
-
545
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
546
- assert(err == 0);
547
-
548
- assert(argc == 2);
549
-
550
- bare_ffmpeg_format_context_t *context;
551
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
552
- assert(err == 0);
553
-
554
- bare_ffmpeg_packet_t *packet;
555
- err = js_get_arraybuffer_info(env, argv[1], (void **) &packet, NULL);
556
- assert(err == 0);
557
-
558
- av_packet_unref(packet->handle);
559
-
560
- err = av_read_frame(context->handle, packet->handle);
561
-
562
- if (err < 0 && err != AVERROR(EAGAIN) && err != AVERROR_EOF) {
563
- err = js_throw_error(env, NULL, av_err2str(err));
564
- assert(err == 0);
565
- }
566
-
567
- js_value_t *result;
568
- err = js_get_boolean(env, err == 0, &result);
569
- assert(err == 0);
570
-
571
- return result;
572
- }
573
-
574
- static js_value_t *
575
- bare_ffmpeg_stream_get_codec(js_env_t *env, js_callback_info_t *info) {
576
- int err;
577
-
578
- size_t argc = 1;
579
- js_value_t *argv[1];
580
-
581
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
582
- assert(err == 0);
583
-
584
- assert(argc == 1);
585
-
586
- bare_ffmpeg_stream_t *stream;
587
- err = js_get_arraybuffer_info(env, argv[0], (void **) &stream, NULL);
588
- assert(err == 0);
589
-
590
- js_value_t *id;
591
- err = js_create_uint32(env, stream->handle->codecpar->codec_id, &id);
592
- assert(err == 0);
593
-
594
- return id;
595
- }
596
-
597
- static js_value_t *
598
- bare_ffmpeg_stream_get_codec_parameters(js_env_t *env, js_callback_info_t *info) {
599
- int err;
600
-
601
- size_t argc = 1;
602
- js_value_t *argv[1];
603
-
604
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
605
- assert(err == 0);
606
-
607
- assert(argc == 1);
608
-
609
- bare_ffmpeg_stream_t *stream;
610
- err = js_get_arraybuffer_info(env, argv[0], (void **) &stream, NULL);
611
- assert(err == 0);
612
-
613
- js_value_t *handle;
614
-
615
- bare_ffmpeg_codec_parameters_t *parameters;
616
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_codec_parameters_t), (void **) &parameters, &handle);
617
- assert(err == 0);
618
-
619
- parameters->handle = stream->handle->codecpar;
620
-
621
- return handle;
622
- }
623
-
624
- static js_value_t *
625
- bare_ffmpeg_find_decoder_by_id(js_env_t *env, js_callback_info_t *info) {
626
- int err;
627
-
628
- size_t argc = 1;
629
- js_value_t *argv[1];
630
-
631
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
632
- assert(err == 0);
633
-
634
- assert(argc == 1);
635
-
636
- uint32_t id;
637
- err = js_get_value_uint32(env, argv[0], &id);
638
- assert(err == 0);
639
-
640
- const AVCodec *decoder = avcodec_find_decoder((enum AVCodecID) id);
641
-
642
- if (decoder == NULL) {
643
- err = js_throw_errorf(env, NULL, "No decoder found for codec '%d'", id);
644
- assert(err == 0);
645
-
646
- return NULL;
647
- }
648
-
649
- js_value_t *handle;
650
-
651
- bare_ffmpeg_codec_t *context;
652
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_codec_t), (void **) &context, &handle);
653
- assert(err == 0);
654
-
655
- context->handle = decoder;
656
-
657
- return handle;
658
- }
659
-
660
- static js_value_t *
661
- bare_ffmpeg_find_encoder_by_id(js_env_t *env, js_callback_info_t *info) {
662
- int err;
663
-
664
- size_t argc = 1;
665
- js_value_t *argv[1];
666
-
667
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
668
- assert(err == 0);
669
-
670
- assert(argc == 1);
671
-
672
- uint32_t id;
673
- err = js_get_value_uint32(env, argv[0], &id);
674
- assert(err == 0);
675
-
676
- const AVCodec *encoder = avcodec_find_encoder((enum AVCodecID) id);
677
-
678
- if (encoder == NULL) {
679
- err = js_throw_errorf(env, NULL, "No encoder found for codec '%d'", id);
680
- assert(err == 0);
681
-
682
- return NULL;
683
- }
684
-
685
- js_value_t *handle;
686
-
687
- bare_ffmpeg_codec_t *context;
688
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_codec_t), (void **) &context, &handle);
689
- assert(err == 0);
690
-
691
- context->handle = encoder;
692
-
693
- return handle;
694
- }
695
-
696
- static js_value_t *
697
- bare_ffmpeg_codec_context_init(js_env_t *env, js_callback_info_t *info) {
698
- int err;
699
-
700
- size_t argc = 1;
701
- js_value_t *argv[1];
702
-
703
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
704
- assert(err == 0);
705
-
706
- assert(argc == 1);
707
-
708
- bare_ffmpeg_codec_t *codec;
709
- err = js_get_arraybuffer_info(env, argv[0], (void **) &codec, NULL);
710
- assert(err == 0);
711
-
712
- js_value_t *handle;
713
-
714
- bare_ffmpeg_codec_context_t *context;
715
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_codec_context_t), (void **) &context, &handle);
716
- assert(err == 0);
717
-
718
- context->handle = avcodec_alloc_context3(codec->handle);
719
-
720
- context->handle->opaque = (void *) context;
721
-
722
- return handle;
723
- }
724
-
725
- static js_value_t *
726
- bare_ffmpeg_codec_context_destroy(js_env_t *env, js_callback_info_t *info) {
727
- int err;
728
-
729
- size_t argc = 1;
730
- js_value_t *argv[1];
731
-
732
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
733
- assert(err == 0);
734
-
735
- assert(argc == 1);
736
-
737
- bare_ffmpeg_codec_context_t *context;
738
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
739
- assert(err == 0);
740
-
741
- avcodec_free_context(&context->handle);
742
-
743
- return NULL;
744
- }
745
-
746
- static js_value_t *
747
- bare_ffmpeg_codec_context_open(js_env_t *env, js_callback_info_t *info) {
748
- int err;
749
-
750
- size_t argc = 1;
751
- js_value_t *argv[1];
752
-
753
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
754
- assert(err == 0);
755
- assert(argc == 1);
756
-
757
- bare_ffmpeg_codec_context_t *context;
758
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
759
- assert(err == 0);
760
-
761
- err = avcodec_open2(context->handle, context->handle->codec, NULL);
762
-
763
- if (err < 0) {
764
- err = js_throw_error(env, NULL, av_err2str(err));
765
- assert(err == 0);
766
- }
767
-
768
- return NULL;
769
- }
770
-
771
- static js_value_t *
772
- bare_ffmpeg_codec_context_open_with_options(js_env_t *env, js_callback_info_t *info) {
773
- int err;
774
-
775
- size_t argc = 2;
776
- js_value_t *argv[2];
777
-
778
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
779
- assert(err == 0);
780
- assert(argc == 2);
781
-
782
- bare_ffmpeg_codec_context_t *context;
783
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
784
- assert(err == 0);
785
-
786
- bare_ffmpeg_dictionary_t *options;
787
- err = js_get_arraybuffer_info(env, argv[1], (void **) &options, NULL);
788
- assert(err == 0);
789
-
790
- err = avcodec_open2(context->handle, context->handle->codec, &options->handle);
791
- if (err < 0) {
792
- err = js_throw_error(env, NULL, av_err2str(err));
793
- assert(err == 0);
794
- }
795
-
796
- return NULL;
797
- }
798
-
799
- static js_value_t *
800
- bare_ffmpeg_codec_context_get_pixel_format(js_env_t *env, js_callback_info_t *info) {
801
- int err;
802
-
803
- size_t argc = 1;
804
- js_value_t *argv[1];
805
-
806
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
807
- assert(err == 0);
808
-
809
- assert(argc == 1);
810
-
811
- bare_ffmpeg_codec_context_t *context;
812
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
813
- assert(err == 0);
814
-
815
- js_value_t *result;
816
- err = js_create_int64(env, context->handle->pix_fmt, &result);
817
- assert(err == 0);
818
-
819
- return result;
820
- }
821
-
822
- static js_value_t *
823
- bare_ffmpeg_codec_context_set_pixel_format(js_env_t *env, js_callback_info_t *info) {
824
- int err;
825
-
826
- size_t argc = 2;
827
- js_value_t *argv[2];
828
-
829
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
830
- assert(err == 0);
831
-
832
- assert(argc == 2);
833
-
834
- bare_ffmpeg_codec_context_t *context;
835
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
836
- assert(err == 0);
837
-
838
- int64_t value;
839
- err = js_get_value_int64(env, argv[1], &value);
840
- assert(err == 0);
841
-
842
- context->handle->pix_fmt = value;
843
-
844
- return NULL;
845
- }
846
-
847
- static js_value_t *
848
- bare_ffmpeg_codec_context_get_width(js_env_t *env, js_callback_info_t *info) {
849
- int err;
850
-
851
- size_t argc = 1;
852
- js_value_t *argv[1];
853
-
854
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
855
- assert(err == 0);
856
-
857
- assert(argc == 1);
858
-
859
- bare_ffmpeg_codec_context_t *context;
860
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
861
- assert(err == 0);
862
-
863
- js_value_t *result;
864
- err = js_create_int64(env, context->handle->width, &result);
865
- assert(err == 0);
866
-
867
- return result;
868
- }
869
-
870
- static js_value_t *
871
- bare_ffmpeg_codec_context_set_width(js_env_t *env, js_callback_info_t *info) {
872
- int err;
873
-
874
- size_t argc = 2;
875
- js_value_t *argv[2];
876
-
877
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
878
- assert(err == 0);
879
-
880
- assert(argc == 2);
881
-
882
- bare_ffmpeg_codec_context_t *context;
883
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
884
- assert(err == 0);
885
-
886
- int64_t value;
887
- err = js_get_value_int64(env, argv[1], &value);
888
- assert(err == 0);
889
-
890
- context->handle->width = value;
891
-
892
- return NULL;
893
- }
894
-
895
- static js_value_t *
896
- bare_ffmpeg_codec_context_get_height(js_env_t *env, js_callback_info_t *info) {
897
- int err;
898
-
899
- size_t argc = 1;
900
- js_value_t *argv[1];
901
-
902
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
903
- assert(err == 0);
904
-
905
- assert(argc == 1);
906
-
907
- bare_ffmpeg_codec_context_t *context;
908
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
909
- assert(err == 0);
910
-
911
- js_value_t *result;
912
- err = js_create_int64(env, context->handle->height, &result);
913
- assert(err == 0);
914
-
915
- return result;
916
- }
917
-
918
- static js_value_t *
919
- bare_ffmpeg_codec_context_set_height(js_env_t *env, js_callback_info_t *info) {
920
- int err;
921
-
922
- size_t argc = 2;
923
- js_value_t *argv[2];
924
-
925
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
926
- assert(err == 0);
927
-
928
- assert(argc == 2);
929
-
930
- bare_ffmpeg_codec_context_t *context;
931
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
932
- assert(err == 0);
933
-
934
- int64_t value;
935
- err = js_get_value_int64(env, argv[1], &value);
936
- assert(err == 0);
937
-
938
- context->handle->height = value;
939
-
940
- return NULL;
941
- }
942
-
943
- static js_value_t *
944
- bare_ffmpeg_codec_context_get_time_base(js_env_t *env, js_callback_info_t *info) {
945
- int err;
946
-
947
- size_t argc = 1;
948
- js_value_t *argv[1];
949
-
950
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
951
- assert(err == 0);
952
-
953
- assert(argc == 1);
954
-
955
- bare_ffmpeg_codec_context_t *context;
956
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
957
- assert(err == 0);
958
-
959
- js_value_t *result;
960
-
961
- int32_t *data;
962
- err = js_create_arraybuffer(env, 2 * sizeof(int32_t), (void **) &data, &result);
963
- assert(err == 0);
964
-
965
- data[0] = context->handle->time_base.num;
966
- data[1] = context->handle->time_base.den;
967
-
968
- return result;
969
- }
970
-
971
- static js_value_t *
972
- bare_ffmpeg_codec_context_set_time_base(js_env_t *env, js_callback_info_t *info) {
973
- int err;
974
-
975
- size_t argc = 2;
976
- js_value_t *argv[2];
977
-
978
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
979
- assert(err == 0);
980
-
981
- assert(argc == 2);
982
-
983
- bare_ffmpeg_codec_context_t *context;
984
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
985
- assert(err == 0);
986
-
987
- int32_t *value;
988
- err = js_get_arraybuffer_info(env, argv[1], (void **) &value, NULL);
989
- assert(err == 0);
990
-
991
- context->handle->time_base.num = value[0];
992
- context->handle->time_base.den = value[1];
993
-
994
- return NULL;
995
- }
996
-
997
- static js_value_t *
998
- bare_ffmpeg_codec_context_send_packet(js_env_t *env, js_callback_info_t *info) {
999
- int err;
1000
-
1001
- size_t argc = 2;
1002
- js_value_t *argv[2];
1003
-
1004
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1005
- assert(err == 0);
1006
-
1007
- assert(argc == 2);
1008
-
1009
- bare_ffmpeg_codec_context_t *context;
1010
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
1011
- assert(err == 0);
1012
-
1013
- bare_ffmpeg_packet_t *packet;
1014
- err = js_get_arraybuffer_info(env, argv[1], (void **) &packet, NULL);
1015
- assert(err == 0);
1016
-
1017
- err = avcodec_send_packet(context->handle, packet->handle);
1018
-
1019
- if (err < 0) {
1020
- err = js_throw_error(env, NULL, av_err2str(err));
1021
- assert(err == 0);
1022
- }
1023
-
1024
- return NULL;
1025
- }
1026
-
1027
- static js_value_t *
1028
- bare_ffmpeg_codec_context_receive_packet(js_env_t *env, js_callback_info_t *info) {
1029
- int err;
1030
-
1031
- size_t argc = 2;
1032
- js_value_t *argv[2];
1033
-
1034
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1035
- assert(err == 0);
1036
- assert(argc == 2);
1037
-
1038
- bare_ffmpeg_codec_context_t *context;
1039
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
1040
- assert(err == 0);
1041
-
1042
- bare_ffmpeg_packet_t *packet;
1043
- err = js_get_arraybuffer_info(env, argv[1], (void **) &packet, NULL);
1044
- assert(err == 0);
1045
-
1046
- err = avcodec_receive_packet(context->handle, packet->handle);
1047
-
1048
- if (err < 0 && err != AVERROR(EAGAIN) && err != AVERROR_EOF) {
1049
- err = js_throw_error(env, NULL, av_err2str(err));
1050
- assert(err == 0);
1051
-
1052
- return NULL;
1053
- }
1054
-
1055
- js_value_t *result;
1056
- err = js_get_boolean(env, err == 0, &result);
1057
- assert(err == 0);
1058
-
1059
- return result;
1060
- }
1061
-
1062
- static js_value_t *
1063
- bare_ffmpeg_codec_context_send_frame(js_env_t *env, js_callback_info_t *info) {
1064
- int err;
1065
-
1066
- size_t argc = 2;
1067
- js_value_t *argv[2];
1068
-
1069
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1070
- assert(err == 0);
1071
- assert(argc == 2);
1072
-
1073
- bare_ffmpeg_codec_context_t *context;
1074
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
1075
- assert(err == 0);
1076
-
1077
- bare_ffmpeg_frame_t *frame;
1078
- err = js_get_arraybuffer_info(env, argv[1], (void **) &frame, NULL);
1079
- assert(err == 0);
1080
-
1081
- err = avcodec_send_frame(context->handle, frame->handle);
1082
-
1083
- if (err == AVERROR(EAGAIN) || err == AVERROR_EOF) {
1084
- js_value_t *result;
1085
- err = js_get_boolean(env, false, &result);
1086
- assert(err == 0);
1087
- return result;
1088
- }
1089
-
1090
- if (err < 0) {
1091
- err = js_throw_error(env, NULL, av_err2str(err));
1092
- assert(err == 0);
1093
-
1094
- return NULL;
1095
- }
1096
-
1097
- js_value_t *result;
1098
- err = js_get_boolean(env, err == 0, &result);
1099
- assert(err == 0);
1100
-
1101
- return result;
1102
- }
1103
-
1104
- static js_value_t *
1105
- bare_ffmpeg_codec_context_receive_frame(js_env_t *env, js_callback_info_t *info) {
1106
- int err;
1107
-
1108
- size_t argc = 2;
1109
- js_value_t *argv[2];
1110
-
1111
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1112
- assert(err == 0);
1113
-
1114
- assert(argc == 2);
1115
-
1116
- bare_ffmpeg_codec_context_t *context;
1117
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
1118
- assert(err == 0);
1119
-
1120
- bare_ffmpeg_frame_t *frame;
1121
- err = js_get_arraybuffer_info(env, argv[1], (void **) &frame, NULL);
1122
- assert(err == 0);
1123
-
1124
- err = avcodec_receive_frame(context->handle, frame->handle);
1125
-
1126
- if (err < 0 && err != AVERROR(EAGAIN) && err != AVERROR_EOF) {
1127
- err = js_throw_error(env, NULL, av_err2str(err));
1128
- assert(err == 0);
1129
-
1130
- return NULL;
1131
- }
1132
-
1133
- js_value_t *result;
1134
- err = js_get_boolean(env, err == 0, &result);
1135
- assert(err == 0);
1136
-
1137
- return result;
1138
- }
1139
-
1140
- static js_value_t *
1141
- bare_ffmpeg_codec_parameters_from_context(js_env_t *env, js_callback_info_t *info) {
1142
- int err;
1143
-
1144
- size_t argc = 2;
1145
- js_value_t *argv[2];
1146
-
1147
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1148
- assert(err == 0);
1149
-
1150
- assert(argc == 2);
1151
-
1152
- bare_ffmpeg_codec_parameters_t *parameters;
1153
- err = js_get_arraybuffer_info(env, argv[0], (void **) &parameters, NULL);
1154
- assert(err == 0);
1155
-
1156
- bare_ffmpeg_codec_context_t *context;
1157
- err = js_get_arraybuffer_info(env, argv[1], (void **) &context, NULL);
1158
- assert(err == 0);
1159
-
1160
- err = avcodec_parameters_from_context(parameters->handle, context->handle);
1161
-
1162
- if (err < 0) {
1163
- err = js_throw_error(env, NULL, av_err2str(err));
1164
- assert(err == 0);
1165
-
1166
- return NULL;
1167
- }
1168
-
1169
- return NULL;
1170
- }
1171
-
1172
- static js_value_t *
1173
- bare_ffmpeg_codec_parameters_to_context(js_env_t *env, js_callback_info_t *info) {
1174
- int err;
1175
-
1176
- size_t argc = 2;
1177
- js_value_t *argv[2];
1178
-
1179
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1180
- assert(err == 0);
1181
-
1182
- assert(argc == 2);
1183
-
1184
- bare_ffmpeg_codec_context_t *context;
1185
- err = js_get_arraybuffer_info(env, argv[0], (void **) &context, NULL);
1186
- assert(err == 0);
1187
-
1188
- bare_ffmpeg_codec_parameters_t *parameters;
1189
- err = js_get_arraybuffer_info(env, argv[1], (void **) &parameters, NULL);
1190
- assert(err == 0);
1191
-
1192
- err = avcodec_parameters_to_context(context->handle, parameters->handle);
1193
-
1194
- if (err < 0) {
1195
- err = js_throw_error(env, NULL, av_err2str(err));
1196
- assert(err == 0);
1197
-
1198
- return NULL;
1199
- }
1200
-
1201
- return NULL;
1202
- }
1203
-
1204
- static js_value_t *
1205
- bare_ffmpeg_codec_parameters_get_bit_rate(js_env_t *env, js_callback_info_t *info) {
1206
- int err;
1207
-
1208
- size_t argc = 1;
1209
- js_value_t *argv[1];
1210
-
1211
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1212
- assert(err == 0);
1213
-
1214
- assert(argc == 1);
1215
-
1216
- bare_ffmpeg_codec_parameters_t *parameters;
1217
- err = js_get_arraybuffer_info(env, argv[0], (void **) &parameters, NULL);
1218
- assert(err == 0);
1219
-
1220
- js_value_t *result;
1221
- err = js_create_int64(env, parameters->handle->bit_rate, &result);
1222
- assert(err == 0);
1223
-
1224
- return result;
1225
- }
1226
-
1227
- static js_value_t *
1228
- bare_ffmpeg_codec_parameters_get_bits_per_coded_sample(js_env_t *env, js_callback_info_t *info) {
1229
- int err;
1230
-
1231
- size_t argc = 1;
1232
- js_value_t *argv[1];
1233
-
1234
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1235
- assert(err == 0);
1236
-
1237
- assert(argc == 1);
1238
-
1239
- bare_ffmpeg_codec_parameters_t *parameters;
1240
- err = js_get_arraybuffer_info(env, argv[0], (void **) &parameters, NULL);
1241
- assert(err == 0);
1242
-
1243
- js_value_t *result;
1244
- err = js_create_int64(env, parameters->handle->bits_per_coded_sample, &result);
1245
- assert(err == 0);
1246
-
1247
- return result;
1248
- }
1249
-
1250
- static js_value_t *
1251
- bare_ffmpeg_codec_parameters_get_bits_per_raw_sample(js_env_t *env, js_callback_info_t *info) {
1252
- int err;
1253
-
1254
- size_t argc = 1;
1255
- js_value_t *argv[1];
1256
-
1257
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1258
- assert(err == 0);
1259
-
1260
- assert(argc == 1);
1261
-
1262
- bare_ffmpeg_codec_parameters_t *parameters;
1263
- err = js_get_arraybuffer_info(env, argv[0], (void **) &parameters, NULL);
1264
- assert(err == 0);
1265
-
1266
- js_value_t *result;
1267
- err = js_create_int64(env, parameters->handle->bits_per_raw_sample, &result);
1268
- assert(err == 0);
1269
-
1270
- return result;
1271
- }
1272
-
1273
- static js_value_t *
1274
- bare_ffmpeg_codec_parameters_get_sample_rate(js_env_t *env, js_callback_info_t *info) {
1275
- int err;
1276
-
1277
- size_t argc = 1;
1278
- js_value_t *argv[1];
1279
-
1280
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1281
- assert(err == 0);
1282
-
1283
- assert(argc == 1);
1284
-
1285
- bare_ffmpeg_codec_parameters_t *parameters;
1286
- err = js_get_arraybuffer_info(env, argv[0], (void **) &parameters, NULL);
1287
- assert(err == 0);
1288
-
1289
- js_value_t *result;
1290
- err = js_create_int64(env, parameters->handle->sample_rate, &result);
1291
- assert(err == 0);
1292
-
1293
- return result;
1294
- }
1295
-
1296
- static js_value_t *
1297
- bare_ffmpeg_frame_init(js_env_t *env, js_callback_info_t *info) {
1298
- int err;
1299
-
1300
- js_value_t *handle;
1301
-
1302
- bare_ffmpeg_frame_t *frame;
1303
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_frame_t), (void **) &frame, &handle);
1304
- assert(err == 0);
1305
-
1306
- frame->handle = av_frame_alloc();
1307
-
1308
- frame->handle->opaque = (void *) frame;
1309
-
1310
- return handle;
1311
- }
1312
-
1313
- static js_value_t *
1314
- bare_ffmpeg_frame_destroy(js_env_t *env, js_callback_info_t *info) {
1315
- int err;
1316
-
1317
- size_t argc = 1;
1318
- js_value_t *argv[1];
1319
-
1320
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1321
- assert(err == 0);
1322
-
1323
- assert(argc == 1);
1324
-
1325
- bare_ffmpeg_frame_t *frame;
1326
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1327
- assert(err == 0);
1328
-
1329
- av_frame_free(&frame->handle);
1330
-
1331
- return NULL;
1332
- }
1333
-
1334
- static js_value_t *
1335
- bare_ffmpeg_frame_get_channel(js_env_t *env, js_callback_info_t *info) {
1336
- int err;
1337
-
1338
- size_t argc = 2;
1339
- js_value_t *argv[2];
1340
-
1341
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1342
- assert(err == 0);
1343
-
1344
- assert(argc == 2);
1345
-
1346
- bare_ffmpeg_frame_t *frame;
1347
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1348
- assert(err == 0);
1349
-
1350
- uint32_t i;
1351
- err = js_get_value_uint32(env, argv[1], &i);
1352
- assert(err == 0);
1353
-
1354
- assert(i < AV_NUM_DATA_POINTERS);
1355
-
1356
- js_value_t *result;
1357
-
1358
- size_t len = frame->handle->linesize[i];
1359
-
1360
- void *data;
1361
- err = js_create_unsafe_arraybuffer(env, len, &data, &result);
1362
- assert(err == 0);
1363
-
1364
- memcpy(data, frame->handle->data[i], len);
1365
-
1366
- return result;
1367
- }
1368
-
1369
- static js_value_t *
1370
- bare_ffmpeg_frame_get_width(js_env_t *env, js_callback_info_t *info) {
1371
- int err;
1372
-
1373
- size_t argc = 1;
1374
- js_value_t *argv[1];
1375
-
1376
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1377
- assert(err == 0);
1378
- assert(argc == 1);
1379
-
1380
- bare_ffmpeg_frame_t *frame;
1381
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1382
- assert(err == 0);
1383
-
1384
- js_value_t *result;
1385
- err = js_create_int32(env, frame->handle->width, &result);
1386
- assert(err == 0);
1387
-
1388
- return result;
1389
- }
1390
-
1391
- static js_value_t *
1392
- bare_ffmpeg_frame_set_width(js_env_t *env, js_callback_info_t *info) {
1393
- int err;
1394
-
1395
- size_t argc = 2;
1396
- js_value_t *argv[2];
1397
-
1398
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1399
- assert(err == 0);
1400
- assert(argc == 2);
1401
-
1402
- bare_ffmpeg_frame_t *frame;
1403
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1404
- assert(err == 0);
1405
-
1406
- int32_t width;
1407
- err = js_get_value_int32(env, argv[1], &width);
1408
- assert(err == 0);
1409
-
1410
- frame->handle->width = width;
1411
-
1412
- return NULL;
1413
- }
1414
-
1415
- static js_value_t *
1416
- bare_ffmpeg_frame_get_height(js_env_t *env, js_callback_info_t *info) {
1417
- int err;
1418
-
1419
- size_t argc = 1;
1420
- js_value_t *argv[1];
1421
-
1422
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1423
- assert(err == 0);
1424
- assert(argc == 1);
1425
-
1426
- bare_ffmpeg_frame_t *frame;
1427
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1428
- assert(err == 0);
1429
-
1430
- js_value_t *result;
1431
- err = js_create_int32(env, frame->handle->height, &result);
1432
- assert(err == 0);
1433
-
1434
- return result;
1435
- }
1436
-
1437
- static js_value_t *
1438
- bare_ffmpeg_frame_set_height(js_env_t *env, js_callback_info_t *info) {
1439
- int err;
1440
-
1441
- size_t argc = 2;
1442
- js_value_t *argv[2];
1443
-
1444
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1445
- assert(err == 0);
1446
- assert(argc == 2);
1447
-
1448
- bare_ffmpeg_frame_t *frame;
1449
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1450
- assert(err == 0);
1451
-
1452
- int32_t height;
1453
- err = js_get_value_int32(env, argv[1], &height);
1454
- assert(err == 0);
1455
-
1456
- frame->handle->height = height;
1457
-
1458
- return NULL;
1459
- }
1460
-
1461
- static js_value_t *
1462
- bare_ffmpeg_frame_get_pixel_format(js_env_t *env, js_callback_info_t *info) {
1463
- int err;
1464
-
1465
- size_t argc = 1;
1466
- js_value_t *argv[1];
1467
-
1468
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1469
- assert(err == 0);
1470
- assert(argc == 1);
1471
-
1472
- bare_ffmpeg_frame_t *frame;
1473
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1474
- assert(err == 0);
1475
-
1476
- js_value_t *result;
1477
- err = js_create_int64(env, frame->handle->format, &result);
1478
- assert(err == 0);
1479
-
1480
- return result;
1481
- }
1482
-
1483
- static js_value_t *
1484
- bare_ffmpeg_frame_set_pixel_format(js_env_t *env, js_callback_info_t *info) {
1485
- int err;
1486
-
1487
- size_t argc = 2;
1488
- js_value_t *argv[2];
1489
-
1490
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1491
- assert(err == 0);
1492
- assert(argc == 2);
1493
-
1494
- bare_ffmpeg_frame_t *frame;
1495
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1496
- assert(err == 0);
1497
-
1498
- int64_t pixel_format;
1499
- err = js_get_value_int64(env, argv[1], &pixel_format);
1500
- assert(err == 0);
1501
-
1502
- frame->handle->format = (enum AVPixelFormat) pixel_format;
1503
-
1504
- return NULL;
1505
- }
1506
-
1507
- static js_value_t *
1508
- bare_ffmpeg_frame_alloc(js_env_t *env, js_callback_info_t *info) {
1509
- int err;
1510
-
1511
- size_t argc = 2;
1512
- js_value_t *argv[2];
1513
-
1514
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1515
- assert(err == 0);
1516
- assert(argc == 2);
1517
-
1518
- bare_ffmpeg_frame_t *frame;
1519
- err = js_get_arraybuffer_info(env, argv[0], (void **) &frame, NULL);
1520
- assert(err == 0);
1521
- assert(frame->handle != NULL);
1522
-
1523
- int align;
1524
- err = js_get_value_int32(env, argv[1], &align);
1525
- assert(err == 0);
1526
- assert(frame->handle != NULL);
1527
-
1528
- err = av_frame_get_buffer(frame->handle, align);
1529
- if (err < 0) {
1530
- err = js_throw_error(env, NULL, av_err2str(err));
1531
- assert(err == 0);
1532
- return NULL;
1533
- }
1534
-
1535
- return NULL;
1536
- }
1537
-
1538
- static js_value_t *
1539
- bare_ffmpeg_image_init(js_env_t *env, js_callback_info_t *info) {
1540
- int err;
1541
-
1542
- size_t argc = 4;
1543
- js_value_t *argv[4];
1544
-
1545
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1546
- assert(err == 0);
1547
-
1548
- assert(argc == 4);
1549
-
1550
- int64_t format;
1551
- err = js_get_value_int64(env, argv[0], &format);
1552
- assert(err == 0);
1553
-
1554
- int32_t width;
1555
- err = js_get_value_int32(env, argv[1], &width);
1556
- assert(err == 0);
1557
-
1558
- int32_t height;
1559
- err = js_get_value_int32(env, argv[2], &height);
1560
- assert(err == 0);
1561
-
1562
- int32_t align;
1563
- err = js_get_value_int32(env, argv[3], &align);
1564
- assert(err == 0);
1565
-
1566
- size_t len = av_image_get_buffer_size((enum AVPixelFormat) format, width, height, align);
1567
-
1568
- js_value_t *handle;
1569
-
1570
- uint8_t *data;
1571
- err = js_create_arraybuffer(env, len, (void **) &data, &handle);
1572
- assert(err == 0);
1573
-
1574
- return handle;
1575
- }
1576
-
1577
- static js_value_t *
1578
- bare_ffmpeg_image_fill(js_env_t *env, js_callback_info_t *info) {
1579
- int err;
1580
-
1581
- size_t argc = 5;
1582
- js_value_t *argv[5];
1583
-
1584
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1585
- assert(err == 0);
1586
-
1587
- assert(argc == 5);
1588
-
1589
- int64_t pixel_format;
1590
- err = js_get_value_int64(env, argv[0], &pixel_format);
1591
- assert(err == 0);
1592
-
1593
- int32_t width;
1594
- err = js_get_value_int32(env, argv[1], &width);
1595
- assert(err == 0);
1596
-
1597
- int32_t height;
1598
- err = js_get_value_int32(env, argv[2], &height);
1599
- assert(err == 0);
1600
-
1601
- uint8_t *data;
1602
- err = js_get_arraybuffer_info(env, argv[3], (void **) &data, NULL);
1603
- assert(err == 0);
1604
-
1605
- bare_ffmpeg_frame_t *frame;
1606
- err = js_get_arraybuffer_info(env, argv[4], (void **) &frame, NULL);
1607
- assert(err == 0);
1608
-
1609
- err = av_image_fill_arrays(frame->handle->data, frame->handle->linesize, data, (enum AVPixelFormat) pixel_format, width, height, 1);
1610
- assert(err >= 0);
1611
-
1612
- return NULL;
1613
- }
1614
-
1615
- static js_value_t *
1616
- bare_ffmpeg_packet_init(js_env_t *env, js_callback_info_t *info) {
1617
- int err;
1618
-
1619
- js_value_t *handle;
1620
-
1621
- bare_ffmpeg_packet_t *packet;
1622
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_packet_t), (void **) &packet, &handle);
1623
- assert(err == 0);
1624
-
1625
- packet->handle = av_packet_alloc();
1626
-
1627
- return handle;
1628
- }
1629
-
1630
- static js_value_t *
1631
- bare_ffmpeg_packet_init_from_buffer(js_env_t *env, js_callback_info_t *info) {
1632
- int err;
1633
-
1634
- size_t argc = 3;
1635
- js_value_t *argv[3];
1636
-
1637
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1638
- assert(err == 0);
1639
- assert(argc == 3);
1640
-
1641
- uint8_t *data;
1642
- err = js_get_arraybuffer_info(env, argv[0], (void **) &data, NULL);
1643
- assert(err == 0);
1644
-
1645
- uint32_t offset;
1646
- err = js_get_value_uint32(env, argv[1], &offset);
1647
- assert(err == 0);
1648
-
1649
- uint32_t len;
1650
- err = js_get_value_uint32(env, argv[2], &len);
1651
- assert(err == 0);
1652
-
1653
- AVPacket *pkt = av_packet_alloc();
1654
- assert(pkt != NULL);
1655
-
1656
- err = av_new_packet(pkt, len);
1657
- assert(err == 0);
1658
-
1659
- memcpy(pkt->data, &data[offset], len);
1660
-
1661
- js_value_t *handle;
1662
- bare_ffmpeg_packet_t *packet;
1663
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_packet_t), (void **) &packet, &handle);
1664
- assert(err == 0);
1665
-
1666
- packet->handle = pkt;
1667
-
1668
- return handle;
1669
- }
1670
-
1671
- static js_value_t *
1672
- bare_ffmpeg_packet_destroy(js_env_t *env, js_callback_info_t *info) {
1673
- int err;
1674
-
1675
- size_t argc = 1;
1676
- js_value_t *argv[1];
1677
-
1678
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1679
- assert(err == 0);
1680
-
1681
- assert(argc == 1);
1682
-
1683
- bare_ffmpeg_packet_t *packet;
1684
- err = js_get_arraybuffer_info(env, argv[0], (void **) &packet, NULL);
1685
- assert(err == 0);
1686
-
1687
- av_packet_unref(packet->handle);
1688
-
1689
- return NULL;
1690
- }
1691
-
1692
- static js_value_t *
1693
- bare_ffmpeg_packet_unref(js_env_t *env, js_callback_info_t *info) {
1694
- int err;
1695
-
1696
- size_t argc = 1;
1697
- js_value_t *argv[1];
1698
-
1699
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1700
- assert(err == 0);
1701
-
1702
- assert(argc == 1);
1703
-
1704
- bare_ffmpeg_packet_t *packet;
1705
- err = js_get_arraybuffer_info(env, argv[0], (void **) &packet, NULL);
1706
- assert(err == 0);
1707
-
1708
- av_packet_unref(packet->handle);
1709
-
1710
- return NULL;
1711
- }
1712
-
1713
- static js_value_t *
1714
- bare_ffmpeg_packet_get_stream_index(js_env_t *env, js_callback_info_t *info) {
1715
- int err;
1716
-
1717
- size_t argc = 1;
1718
- js_value_t *argv[1];
1719
-
1720
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1721
- assert(err == 0);
1722
-
1723
- assert(argc == 1);
1724
-
1725
- bare_ffmpeg_packet_t *packet;
1726
- err = js_get_arraybuffer_info(env, argv[0], (void **) &packet, NULL);
1727
- assert(err == 0);
1728
-
1729
- js_value_t *result;
1730
- err = js_create_int32(env, packet->handle->stream_index, &result);
1731
- assert(err == 0);
1732
-
1733
- return result;
1734
- }
1735
-
1736
- static js_value_t *
1737
- bare_ffmpeg_packet_get_data(js_env_t *env, js_callback_info_t *info) {
1738
- int err;
1739
-
1740
- size_t argc = 1;
1741
- js_value_t *argv[1];
1742
-
1743
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1744
- assert(err == 0);
1745
-
1746
- assert(argc == 1);
1747
-
1748
- bare_ffmpeg_packet_t *packet;
1749
- err = js_get_arraybuffer_info(env, argv[0], (void **) &packet, NULL);
1750
- assert(err == 0);
1751
-
1752
- js_value_t *result;
1753
- uint8_t *data;
1754
- err = js_create_arraybuffer(env, packet->handle->size, (void **) &data, &result);
1755
- assert(err == 0);
1756
-
1757
- memcpy(data, packet->handle->data, packet->handle->size);
1758
-
1759
- return result;
1760
- }
1761
-
1762
- static js_value_t *
1763
- bare_ffmpeg_scaler_init(js_env_t *env, js_callback_info_t *info) {
1764
- int err;
1765
-
1766
- size_t argc = 6;
1767
- js_value_t *argv[6];
1768
-
1769
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1770
- assert(err == 0);
1771
-
1772
- assert(argc == 6);
1773
-
1774
- int64_t source_format;
1775
- err = js_get_value_int64(env, argv[0], &source_format);
1776
- assert(err == 0);
1777
-
1778
- int32_t source_width;
1779
- err = js_get_value_int32(env, argv[1], &source_width);
1780
- assert(err == 0);
1781
-
1782
- int32_t source_height;
1783
- err = js_get_value_int32(env, argv[2], &source_height);
1784
- assert(err == 0);
1785
-
1786
- int64_t target_format;
1787
- err = js_get_value_int64(env, argv[3], &target_format);
1788
- assert(err == 0);
1789
-
1790
- int32_t target_width;
1791
- err = js_get_value_int32(env, argv[4], &target_width);
1792
- assert(err == 0);
1793
-
1794
- int32_t target_height;
1795
- err = js_get_value_int32(env, argv[5], &target_height);
1796
- assert(err == 0);
1797
-
1798
- js_value_t *handle;
1799
-
1800
- bare_ffmpeg_scaler_t *scaler;
1801
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_scaler_t), (void **) &scaler, &handle);
1802
- assert(err == 0);
1803
-
1804
- scaler->handle = sws_getContext(
1805
- source_width,
1806
- source_height,
1807
- (enum AVPixelFormat) source_format,
1808
- target_width,
1809
- target_height,
1810
- (enum AVPixelFormat) target_format,
1811
- SWS_BICUBIC,
1812
- NULL,
1813
- NULL,
1814
- NULL
1815
- );
1816
-
1817
- return handle;
1818
- }
1819
-
1820
- static js_value_t *
1821
- bare_ffmpeg_scaler_destroy(js_env_t *env, js_callback_info_t *info) {
1822
- int err;
1823
-
1824
- size_t argc = 1;
1825
- js_value_t *argv[1];
1826
-
1827
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1828
- assert(err == 0);
1829
-
1830
- assert(argc == 1);
1831
-
1832
- bare_ffmpeg_scaler_t *scaler;
1833
- err = js_get_arraybuffer_info(env, argv[0], (void **) &scaler, NULL);
1834
- assert(err == 0);
1835
-
1836
- sws_freeContext(scaler->handle);
1837
-
1838
- return NULL;
1839
- }
1840
-
1841
- static js_value_t *
1842
- bare_ffmpeg_scaler_scale(js_env_t *env, js_callback_info_t *info) {
1843
- int err;
1844
-
1845
- size_t argc = 5;
1846
- js_value_t *argv[5];
1847
-
1848
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1849
- assert(err == 0);
1850
-
1851
- assert(argc == 5);
1852
-
1853
- bare_ffmpeg_scaler_t *scaler;
1854
- err = js_get_arraybuffer_info(env, argv[0], (void **) &scaler, NULL);
1855
- assert(err == 0);
1856
-
1857
- bare_ffmpeg_frame_t *source;
1858
- err = js_get_arraybuffer_info(env, argv[1], (void **) &source, NULL);
1859
- assert(err == 0);
1860
-
1861
- int64_t y;
1862
- err = js_get_value_int64(env, argv[2], &y);
1863
- assert(err == 0);
1864
-
1865
- int64_t height;
1866
- err = js_get_value_int64(env, argv[3], &height);
1867
- assert(err == 0);
1868
-
1869
- bare_ffmpeg_frame_t *target;
1870
- err = js_get_arraybuffer_info(env, argv[4], (void **) &target, NULL);
1871
- assert(err == 0);
1872
-
1873
- height = sws_scale(
1874
- scaler->handle,
1875
- (const uint8_t *const *) source->handle->data,
1876
- source->handle->linesize,
1877
- y,
1878
- height,
1879
- target->handle->data,
1880
- target->handle->linesize
1881
- );
1882
-
1883
- js_value_t *result;
1884
- err = js_create_int64(env, height, &result);
1885
- assert(err == 0);
1886
-
1887
- return result;
1888
- }
1889
-
1890
- static js_value_t *
1891
- bare_ffmpeg_dictionary_init(js_env_t *env, js_callback_info_t *info) {
1892
- int err;
1893
- js_value_t *handle;
1894
-
1895
- bare_ffmpeg_dictionary_t *dict;
1896
- err = js_create_arraybuffer(env, sizeof(bare_ffmpeg_dictionary_t), (void **) &dict, &handle);
1897
- assert(err == 0);
1898
-
1899
- dict->handle = NULL;
1900
-
1901
- return handle;
1902
- }
1903
-
1904
- static js_value_t *
1905
- bare_ffmpeg_dictionary_destroy(js_env_t *env, js_callback_info_t *info) {
1906
- int err;
1907
-
1908
- size_t argc = 1;
1909
- js_value_t *argv[1];
1910
-
1911
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1912
- assert(err == 0);
1913
- assert(argc == 1);
1914
-
1915
- bare_ffmpeg_dictionary_t *dict;
1916
- err = js_get_arraybuffer_info(env, argv[0], (void **) &dict, NULL);
1917
- assert(err == 0);
1918
-
1919
- av_dict_free(&dict->handle);
1920
-
1921
- return NULL;
1922
- }
1923
-
1924
- static js_value_t *
1925
- bare_ffmpeg_dictionary_set_entry(js_env_t *env, js_callback_info_t *info) {
1926
- int err;
1927
-
1928
- size_t argc = 3;
1929
- js_value_t *argv[3];
1930
-
1931
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1932
- assert(err == 0);
1933
- assert(argc == 3);
1934
-
1935
- bare_ffmpeg_dictionary_t *dict;
1936
- err = js_get_arraybuffer_info(env, argv[0], (void **) &dict, NULL);
1937
- assert(err == 0);
1938
-
1939
- size_t len;
1940
- err = js_get_value_string_utf8(env, argv[1], NULL, 0, &len);
1941
- assert(err == 0);
1942
-
1943
- len += +1 /* NULL */;
1944
-
1945
- utf8_t *key = malloc(len);
1946
- err = js_get_value_string_utf8(env, argv[1], key, len, NULL);
1947
- assert(err == 0);
1948
-
1949
- err = js_get_value_string_utf8(env, argv[2], NULL, 0, &len);
1950
- assert(err == 0);
1951
-
1952
- len += +1 /* NULL */;
1953
-
1954
- utf8_t *value = malloc(len);
1955
- err = js_get_value_string_utf8(env, argv[2], value, len, NULL);
1956
- assert(err == 0);
1957
-
1958
- err = av_dict_set(&dict->handle, (const char *) key, (const char *) value, 0);
1959
- assert(err == 0);
1960
- free(key);
1961
- free(value);
1962
-
1963
- return NULL;
1964
- }
1965
-
1966
- static js_value_t *
1967
- bare_ffmpeg_dictionary_get_entry(js_env_t *env, js_callback_info_t *info) {
1968
- int err;
1969
-
1970
- size_t argc = 2;
1971
- js_value_t *argv[2];
1972
-
1973
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
1974
- assert(err == 0);
1975
- assert(argc == 2);
1976
-
1977
- bare_ffmpeg_dictionary_t *dict;
1978
- err = js_get_arraybuffer_info(env, argv[0], (void **) &dict, NULL);
1979
- assert(err == 0);
1980
-
1981
- size_t len;
1982
- err = js_get_value_string_utf8(env, argv[1], NULL, 0, &len);
1983
- assert(err == 0);
1984
-
1985
- len += +1 /* NULL */;
1986
-
1987
- utf8_t *key = malloc(len);
1988
- err = js_get_value_string_utf8(env, argv[1], key, len, NULL);
1989
- assert(err == 0);
1990
-
1991
- AVDictionaryEntry *entry = av_dict_get(dict->handle, (const char *) key, NULL, 0);
1992
- free(key);
1993
-
1994
- if (entry == NULL) {
1995
- js_value_t *result;
1996
- err = js_get_null(env, &result);
1997
- assert(err == 0);
1998
- return result;
1999
- }
2000
-
2001
- js_value_t *result;
2002
- err = js_create_string_utf8(env, (const utf8_t *) entry->value, -1, &result);
2003
- assert(err == 0);
2004
-
2005
- return result;
2006
- }
2007
-
2008
- static js_value_t *
2009
- bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
2010
- uv_once(&bare_ffmpeg__init_guard, bare_ffmpeg__on_init);
2011
-
2012
- int err;
2013
-
2014
- #define V(name, fn) \
2015
- { \
2016
- js_value_t *val; \
2017
- err = js_create_function(env, name, -1, fn, NULL, &val); \
2018
- assert(err == 0); \
2019
- err = js_set_named_property(env, exports, name, val); \
2020
- assert(err == 0); \
2021
- }
2022
-
2023
- V("initIOContext", bare_ffmpeg_io_context_init)
2024
- V("destroyIOContext", bare_ffmpeg_io_context_destroy)
2025
-
2026
- V("initOutputFormat", bare_ffmpeg_output_format_init)
2027
- V("initInputFormat", bare_ffmpeg_input_format_init)
2028
-
2029
- V("openInputFormatContextWithIO", bare_ffmpeg_format_context_open_input_with_io)
2030
- V("openInputFormatContextWithFormat", bare_ffmpeg_format_context_open_input_with_format)
2031
- V("closeInputFormatContext", bare_ffmpeg_format_context_close_input)
2032
- V("openOutputFormatContext", bare_ffmpeg_format_context_open_output)
2033
- V("closeOutputFormatContext", bare_ffmpeg_format_context_close_output)
2034
- V("getFormatContextStreams", bare_ffmpeg_format_context_get_streams)
2035
- V("getFormatContextBestStreamIndex", bare_ffmpeg_format_context_get_best_stream_index)
2036
- V("createFormatContextStream", bare_ffmpeg_format_context_create_stream)
2037
- V("readFormatContextFrame", bare_ffmpeg_format_context_read_frame)
2038
-
2039
- V("getStreamCodec", bare_ffmpeg_stream_get_codec)
2040
- V("getStreamCodecParameters", bare_ffmpeg_stream_get_codec_parameters)
2041
-
2042
- V("findDecoderByID", bare_ffmpeg_find_decoder_by_id)
2043
- V("findEncoderByID", bare_ffmpeg_find_encoder_by_id)
2044
-
2045
- V("initCodecContext", bare_ffmpeg_codec_context_init)
2046
- V("destroyCodecContext", bare_ffmpeg_codec_context_destroy)
2047
- V("openCodecContext", bare_ffmpeg_codec_context_open)
2048
- V("openCodecContextWithOptions", bare_ffmpeg_codec_context_open_with_options)
2049
- V("getCodecContextPixelFormat", bare_ffmpeg_codec_context_get_pixel_format)
2050
- V("setCodecContextPixelFormat", bare_ffmpeg_codec_context_set_pixel_format)
2051
- V("getCodecContextWidth", bare_ffmpeg_codec_context_get_width)
2052
- V("setCodecContextWidth", bare_ffmpeg_codec_context_set_width)
2053
- V("getCodecContextHeight", bare_ffmpeg_codec_context_get_height)
2054
- V("setCodecContextHeight", bare_ffmpeg_codec_context_set_height)
2055
- V("getCodecContextTimeBase", bare_ffmpeg_codec_context_get_time_base)
2056
- V("setCodecContextTimeBase", bare_ffmpeg_codec_context_set_time_base)
2057
- V("sendCodecContextPacket", bare_ffmpeg_codec_context_send_packet)
2058
- V("receiveCodecContextPacket", bare_ffmpeg_codec_context_receive_packet)
2059
- V("sendCodecContextFrame", bare_ffmpeg_codec_context_send_frame)
2060
- V("receiveCodecContextFrame", bare_ffmpeg_codec_context_receive_frame)
2061
-
2062
- V("codecParametersFromContext", bare_ffmpeg_codec_parameters_from_context)
2063
- V("codecParametersToContext", bare_ffmpeg_codec_parameters_to_context)
2064
- V("getCodecParametersBitRate", bare_ffmpeg_codec_parameters_get_bit_rate)
2065
- V("getCodecParametersBitsPerCodedSample", bare_ffmpeg_codec_parameters_get_bits_per_coded_sample)
2066
- V("getCodecParametersBitsPerRawSample", bare_ffmpeg_codec_parameters_get_bits_per_raw_sample)
2067
- V("getCodecParametersSampleRate", bare_ffmpeg_codec_parameters_get_sample_rate)
2068
-
2069
- V("initFrame", bare_ffmpeg_frame_init)
2070
- V("destroyFrame", bare_ffmpeg_frame_destroy)
2071
- V("getFrameChannel", bare_ffmpeg_frame_get_channel)
2072
- V("getFrameWidth", bare_ffmpeg_frame_get_width)
2073
- V("setFrameWidth", bare_ffmpeg_frame_set_width)
2074
- V("getFrameHeight", bare_ffmpeg_frame_get_height)
2075
- V("setFrameHeight", bare_ffmpeg_frame_set_height)
2076
- V("getFramePixelFormat", bare_ffmpeg_frame_get_pixel_format)
2077
- V("setFramePixelFormat", bare_ffmpeg_frame_set_pixel_format)
2078
- V("allocFrame", bare_ffmpeg_frame_alloc)
2079
-
2080
- V("initImage", bare_ffmpeg_image_init)
2081
- V("fillImage", bare_ffmpeg_image_fill)
2082
-
2083
- V("initPacket", bare_ffmpeg_packet_init)
2084
- V("initPacketFromBuffer", bare_ffmpeg_packet_init_from_buffer)
2085
- V("destroyPacket", bare_ffmpeg_packet_destroy)
2086
- V("unrefPacket", bare_ffmpeg_packet_unref)
2087
- V("getPacketStreamIndex", bare_ffmpeg_packet_get_stream_index)
2088
- V("getPacketData", bare_ffmpeg_packet_get_data)
2089
-
2090
- V("initScaler", bare_ffmpeg_scaler_init)
2091
- V("destroyScaler", bare_ffmpeg_scaler_destroy)
2092
- V("scaleScaler", bare_ffmpeg_scaler_scale)
2093
-
2094
- V("initDictionary", bare_ffmpeg_dictionary_init)
2095
- V("destroyDictionary", bare_ffmpeg_dictionary_destroy)
2096
- V("getDictionaryEntry", bare_ffmpeg_dictionary_get_entry)
2097
- V("setDictionaryEntry", bare_ffmpeg_dictionary_set_entry)
2098
- #undef V
2099
-
2100
- #define V(name) \
2101
- { \
2102
- js_value_t *val; \
2103
- err = js_create_int64(env, name, &val); \
2104
- assert(err == 0); \
2105
- err = js_set_named_property(env, exports, #name, val); \
2106
- assert(err == 0); \
2107
- }
2108
-
2109
- V(AV_CODEC_ID_MJPEG)
2110
- V(AV_CODEC_ID_H264)
2111
-
2112
- V(AV_PIX_FMT_RGBA)
2113
- V(AV_PIX_FMT_YUVJ420P)
2114
- V(AV_PIX_FMT_YUV420P)
2115
-
2116
- V(AVMEDIA_TYPE_UNKNOWN)
2117
- V(AVMEDIA_TYPE_VIDEO)
2118
- V(AVMEDIA_TYPE_AUDIO)
2119
- V(AVMEDIA_TYPE_DATA)
2120
- V(AVMEDIA_TYPE_SUBTITLE)
2121
- V(AVMEDIA_TYPE_ATTACHMENT)
2122
- V(AVMEDIA_TYPE_NB)
2123
- #undef V
2124
-
2125
- return exports;
2126
- }
2127
-
2128
- BARE_MODULE(bare_ffmpeg, bare_ffmpeg_exports)