bare-ffmpeg 1.0.0-4 → 1.0.0-7

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